diff --git a/src/main/java/models/formulas/DependencyFormula.java b/src/main/java/models/formulas/DependencyFormula.java index 269aafd..cc70ee5 100644 --- a/src/main/java/models/formulas/DependencyFormula.java +++ b/src/main/java/models/formulas/DependencyFormula.java @@ -1,5 +1,7 @@ package models.formulas; +import java.util.List; + import lombok.Getter; import models.terms.Dependency; import models.terms.RDLTerm; @@ -14,8 +16,8 @@ this.dependency = dependency; } - public DependencyFormula(RDLTerm dependingTerm, Resource dependedVariable) { - this.dependency = new Dependency(dependingTerm, dependedVariable); + public DependencyFormula(RDLTerm dependingTerm, List dependedResources) { + this.dependency = new Dependency(dependingTerm, dependedResources); } diff --git a/src/main/java/models/terms/Dependency.java b/src/main/java/models/terms/Dependency.java index eee07c7..c0bcf00 100644 --- a/src/main/java/models/terms/Dependency.java +++ b/src/main/java/models/terms/Dependency.java @@ -1,5 +1,10 @@ package models.terms; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + import lombok.Getter; import models.algebra.Symbol; @@ -7,46 +12,62 @@ public class Dependency extends RDLTerm{ private RDLTerm dependingTerm; - private Resource dependedVariable; + private List dependedResources; private Dependency dependency; private boolean isListType; - public Dependency(RDLTerm dependingTerm, Resource dependedVariable) { - super(new Symbol(":", 2), dependedVariable.getOrder(), dependingTerm.getSize() + dependedVariable.getSize()); +// public Dependency(RDLTerm dependingTerm, Resource dependedVariable) { +// super(new Symbol(":", 2), dependedVariable.getOrder(), dependingTerm.getSize() + dependedVariable.getSize()); +// this.dependingTerm = dependingTerm; +// this.dependedVariable = dependedVariable; +// this.dependency = null; +// this.addChild(dependingTerm); +// this.addChild(dependedVariable); +// this.isListType = false; +// } + + public Dependency(RDLTerm dependingTerm, List dependedResources) { + super(new Symbol(":", dependedResources.size() + 1), dependedResources.get(0).getOrder(), dependingTerm.getSize() + dependedResources.stream().mapToInt(v -> v.size).sum()); this.dependingTerm = dependingTerm; - this.dependedVariable = dependedVariable; + this.dependedResources = dependedResources; this.dependency = null; this.addChild(dependingTerm); - this.addChild(dependedVariable); + for (Resource dependedResource: dependedResources) { + this.addChild(dependedResource); + } this.isListType = false; } + public Dependency(RDLTerm dependingTerm, Resource ...dependedResources) { + this(dependingTerm, Arrays.asList(dependedResources)); + } + public Dependency(Dependency dependency) { super(new Symbol(":", 1), dependency.getOrder() - 1, dependency.getSize()); this.dependency = dependency; this.dependingTerm = null; - this.dependedVariable = null; + this.dependedResources = null; this.addChild(dependency); this.isListType = true; } - public Dependency(RDLTerm dependingTerm, Resource dependedVariable, int order) { - super(new Symbol(":", order == dependedVariable.order ? 2 : 1), order, dependingTerm.getSize() + dependedVariable.getSize()); - if(order == dependedVariable.order) { - this.dependingTerm = dependingTerm; - this.dependedVariable = dependedVariable; - this.addChild(dependingTerm); - this.addChild(dependedVariable); - this.dependency = null; - this.isListType = false; - } else { - this.dependency = new Dependency(dependingTerm, dependedVariable, order+1); - this.dependingTerm = null; - this.dependedVariable = null; - this.addChild(dependency); - this.isListType = true; - } - } +// public Dependency(RDLTerm dependingTerm, Resource dependedVariable, int order) { +// super(new Symbol(":", order == dependedVariable.order ? 2 : 1), order, dependingTerm.getSize() + dependedVariable.getSize()); +// if(order == dependedVariable.order) { +// this.dependingTerm = dependingTerm; +// this.dependedResources = dependedVariable; +// this.addChild(dependingTerm); +// this.addChild(dependedVariable); +// this.dependency = null; +// this.isListType = false; +// } else { +// this.dependency = new Dependency(dependingTerm, dependedVariable, order+1); +// this.dependingTerm = null; +// this.dependedResources = null; +// this.addChild(dependency); +// this.isListType = true; +// } +// } public Dependency getDependency() { return this.dependency; @@ -61,28 +82,13 @@ return dependingTerm instanceof EvaluatableTerm; } - public void setDependingTerm(RDLTerm newTerm) { - setChild(0, newTerm); - this.dependingTerm = newTerm; - } - - public void setDependedVariable(Resource newVariable) { - setChild(1, newVariable); - this.dependedVariable = newVariable; - } - - public void setDependency(Dependency newDependency) { - setChild(0, newDependency); - this.dependency = newDependency; - } - @Override public String toString() { StringBuilder sb = new StringBuilder(); if(dependency == null) { sb.append(dependingTerm.toTermString()); sb.append(" : "); - sb.append(dependedVariable.toString()); + sb.append(dependedResources.toString()); } else { sb.append('['); sb.append(dependency.toString()); @@ -97,7 +103,7 @@ if(dependency == null) { sb.append(dependingTerm.toStringWithOrder()); sb.append(" : "); - sb.append(dependedVariable.toStringWithOrder()); + sb.append(dependedResources.stream().map(RDLTerm::toStringWithOrder).collect(Collectors.joining(", "))); } else { sb.append('['); sb.append(dependency.toStringWithOrder()); @@ -124,7 +130,7 @@ return anotherDep.getDependency().equals(dependency); } return anotherDep.getDependingTerm().equals(dependingTerm) - && anotherDep.getDependedVariable().equals(dependedVariable); + && anotherDep.getDependedResources().equals(dependedResources); } @Override @@ -134,7 +140,7 @@ @Override public Object clone() { - return new Dependency((RDLTerm) dependingTerm.clone(), (Resource) dependedVariable.clone()); + return new Dependency((RDLTerm) dependingTerm.clone(), new ArrayList<>(dependedResources)); } } diff --git a/src/main/java/models/terms/DependencyTerm.java b/src/main/java/models/terms/DependencyTerm.java index a84c945..667fa68 100644 --- a/src/main/java/models/terms/DependencyTerm.java +++ b/src/main/java/models/terms/DependencyTerm.java @@ -15,31 +15,27 @@ private List argumentTerms = new ArrayList<>(); -// 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, List dependedTerms, List argumentTerms) { super( 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() + -1, + dependingTerm.getSize() + argumentTerms.stream().mapToInt(RDLTerm::getSize).sum() + dependedTerms.stream().mapToInt(RDLTerm::getSize).sum() ); - 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)) { - throw new RuntimeException("Orders are not all equals"); + int maxOrder = argumentTerms.stream().mapToInt(EvaluatableTerm::getOrder).max().orElse(-1); + if (dependedTerms.get(0).getOrder() < maxOrder) { + this.order = dependingTerm.getOrder() + (maxOrder - dependedTerms.get(0).getOrder()); + } else if (dependedTerms.get(0).getOrder() == maxOrder) { + this.order = dependingTerm.getOrder(); + } else { + this.order = dependingTerm.getOrder() - 1; } + + for(int i = 0; i < dependedTerms.size(); i++) { + if (dependedTerms.get(0).getOrder() != dependedTerms.get(i).getOrder()) { + throw new RuntimeException("dependedTerms order not equals"); + } + } + if (dependedTerms.size() != argumentTerms.size()) { throw new RuntimeException("Size not equals"); } diff --git a/src/test/java/terms/LinearRightNormalTest.java b/src/test/java/terms/LinearRightNormalTest.java index 1b48e72..f3097a8 100644 --- a/src/test/java/terms/LinearRightNormalTest.java +++ b/src/test/java/terms/LinearRightNormalTest.java @@ -1,96 +1,81 @@ package terms; -import static org.junit.jupiter.api.Assertions.*; - -import org.junit.jupiter.api.Test; - -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.Resource; -import models.terms.meta.MetaEvaluatableTermVariable; -import models.terms.meta.MetaRDLTerm; -import models.terms.meta.MetaResource; - public class LinearRightNormalTest { - Type INT = DataConstraintModel.typeInt; - - @Test - void linearRightNormalTest() { - - - Resource a = new Resource("A", INT, 2); - Resource b = new Resource("B", INT, 2); - Resource c = new Resource("C", INT, 2); - Resource d = new Resource("D", INT, 2); - Resource e = new Resource("E", INT, 2); - Resource f = new Resource("F", INT, 2); - Resource g = new Resource("G", INT, 1); - - 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 = 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); - } - - @Test - void linearRightNormalizeTest() { - - Resource a = new Resource("A", INT, 2); - Resource b = new Resource("B", INT, 2); - Resource c = new Resource("C", INT, 2); - Resource d = new Resource("D", INT, 2); - Resource e = new Resource("E", INT, 2); - Resource f = new Resource("F", INT, 2); - Resource g = new Resource("G", INT, 1); - - 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(); - assertEquals(te3.isLinearRightNormalized(), true); - } - - @Test - void linearRightNomalizedMatchTest() { - Resource a = new Resource("A", INT, 2); - Resource b = new Resource("B", INT, 2); - Resource c = new Resource("C", INT, 2); - Resource d = new Resource("D", INT, 2); - Resource e = new Resource("E", INT, 2); - Resource f = new Resource("F", INT, 2); - Resource g = new Resource("G", INT, 1); - - 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")); - MetaResource metaA = new MetaResource(new Variable("ma")); - MetaResource metaB = new MetaResource(new Variable("mb")); - MetaResource metaC = new MetaResource(new Variable("mc")); - MetaRDLTerm metaTerm2 = new MetaRDLTerm(metaA, metaB, metaC); - metaTerm2.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); - - - metaTerm.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); - assertEquals(metaTerm.isMatchedBy(te3), false); - te3.selfLinearRightNormalize(); - assertEquals(metaTerm.isMatchedBy(te3), true); - assertEquals(metaTerm2.isMatchedBy(te1), true); - } +// Type INT = DataConstraintModel.typeInt; +// +// @Test +// void linearRightNormalTest() { +// +// +// Resource a = new Resource("A", INT, 2); +// Resource b = new Resource("B", INT, 2); +// Resource c = new Resource("C", INT, 2); +// Resource d = new Resource("D", INT, 2); +// Resource e = new Resource("E", INT, 2); +// Resource f = new Resource("F", INT, 2); +// Resource g = new Resource("G", INT, 1); +// +// 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 = 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); +// } +// +// @Test +// void linearRightNormalizeTest() { +// +// Resource a = new Resource("A", INT, 2); +// Resource b = new Resource("B", INT, 2); +// Resource c = new Resource("C", INT, 2); +// Resource d = new Resource("D", INT, 2); +// Resource e = new Resource("E", INT, 2); +// Resource f = new Resource("F", INT, 2); +// Resource g = new Resource("G", INT, 1); +// +// 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(); +// assertEquals(te3.isLinearRightNormalized(), true); +// } +// +// @Test +// void linearRightNomalizedMatchTest() { +// Resource a = new Resource("A", INT, 2); +// Resource b = new Resource("B", INT, 2); +// Resource c = new Resource("C", INT, 2); +// Resource d = new Resource("D", INT, 2); +// Resource e = new Resource("E", INT, 2); +// Resource f = new Resource("F", INT, 2); +// Resource g = new Resource("G", INT, 1); +// +// 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")); +// MetaResource metaA = new MetaResource(new Variable("ma")); +// MetaResource metaB = new MetaResource(new Variable("mb")); +// MetaResource metaC = new MetaResource(new Variable("mc")); +// MetaRDLTerm metaTerm2 = new MetaRDLTerm(metaA, metaB, metaC); +// metaTerm2.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); +// +// +// metaTerm.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); +// assertEquals(metaTerm.isMatchedBy(te3), false); +// te3.selfLinearRightNormalize(); +// assertEquals(metaTerm.isMatchedBy(te3), true); +// assertEquals(metaTerm2.isMatchedBy(te1), true); +// } } diff --git a/src/test/java/terms/OrderTest.java b/src/test/java/terms/OrderTest.java new file mode 100644 index 0000000..930c154 --- /dev/null +++ b/src/test/java/terms/OrderTest.java @@ -0,0 +1,57 @@ +package terms; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +import models.terms.DependencyTerm; +import models.terms.Resource; +import utils.Utils; + +public class OrderTest { + + @Test + void singleDependencyTermOrderTest() { + Resource A = new Resource("A", Utils.INT, 1); + Resource B = new Resource("B", Utils.INT, 1); + Resource C = new Resource("C", Utils.INT, 1); + Resource D = new Resource("D", Utils.INT, 2); + Resource E = new Resource("E", Utils.INT, 0); + + DependencyTerm t1 = new DependencyTerm(A, B, C); + assertEquals(t1.getOrder(), 1); + DependencyTerm t2 = new DependencyTerm(A, B, D); + assertEquals(t2.getOrder(), 2); + DependencyTerm t3 = new DependencyTerm(A, B, E); + assertEquals(t3.getOrder(), 0); + + } + + @Test + void multiDependencyTermOrderTest() { + Resource A = new Resource("A", Utils.INT, 1); + Resource B = new Resource("B", Utils.INT, 1); + Resource C = new Resource("C", Utils.INT, 1); + Resource D = new Resource("D", Utils.INT, 1); + Resource E = new Resource("E", Utils.INT, 1); + Resource F = new Resource("F", Utils.INT, 2); + Resource G = new Resource("G", Utils.INT, 0); + + DependencyTerm t1 = new DependencyTerm(A, B, C, D, E); + assertEquals(t1.getOrder(), 1); + + DependencyTerm t2 = new DependencyTerm(A, B, C, D, F); + assertEquals(t2.getOrder(), 2); + + DependencyTerm t3 = new DependencyTerm(A, B, C, D, G); + assertEquals(t3.getOrder(), 1); + + assertThrows(RuntimeException.class, () -> { + new DependencyTerm(A, B, C, G, D); + }); + + } + + + +}