diff --git a/src/Main.java b/src/Main.java index d79a6cb..270ae23 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,5 +1,5 @@ -import models.EvaluableTerm; -import models.RDLVariable; +import models.EvaluatableTerm; +import models.ResourceVariable; import models.algebra.Type; import models.dataConstraintModel.DataConstraintModel; @@ -10,38 +10,29 @@ Type INT = DataConstraintModel.typeInt; Type STR = DataConstraintModel.typeString; - RDLVariable a = EvaluableTerm.of("A", INT, 2); - RDLVariable b = EvaluableTerm.of("B", INT, 2); - RDLVariable c = EvaluableTerm.of("C", INT, 2); - RDLVariable d = EvaluableTerm.of("D", INT, 2); - RDLVariable e = EvaluableTerm.of("E", INT, 1); - RDLVariable f = EvaluableTerm.of("F", INT, 1); - RDLVariable g = EvaluableTerm.of("G", INT, 1); - RDLVariable h = EvaluableTerm.of("H", INT, 1); - RDLVariable i = EvaluableTerm.of("I", INT, 0); + 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, 1); + ResourceVariable f = EvaluatableTerm.of("F", INT, 1); + ResourceVariable g = EvaluatableTerm.of("G", INT, 1); + ResourceVariable h = EvaluatableTerm.of("H", INT, 1); + ResourceVariable i = EvaluatableTerm.of("I", INT, 0); - EvaluableTerm te1 = EvaluableTerm.of(g, h, i); - EvaluableTerm te2 = EvaluableTerm.of(a, b, c); - EvaluableTerm te3 = EvaluableTerm.of(te2, d, e); - EvaluableTerm te4 = EvaluableTerm.of(te3, f, te1); + EvaluatableTerm te1 = EvaluatableTerm.of(g, h, i); + EvaluatableTerm te2 = EvaluatableTerm.of(a, b, c); + EvaluatableTerm te3 = EvaluatableTerm.of(te2, d, e); + EvaluatableTerm te4 = EvaluatableTerm.of(te3, f, te1); + var te5 = te4.linearRightNormalize(); System.out.println(te4.toStr()); + System.out.println(te4.getOrder()); te4.selfLinearRightNormalize(); System.out.println(te4.toStr()); System.out.println(te4.isLinearRightNormal()); System.out.println(te4.getOrder()); - System.out.println("========================"); - - EvaluableTerm te5 = EvaluableTerm.of(c, d, e); - EvaluableTerm te6 = EvaluableTerm.of(g, h, i); - EvaluableTerm te7 = EvaluableTerm.of(a, b, te5); - EvaluableTerm te8 = EvaluableTerm.of(te7, f, te6); - System.out.println(te8.toStr()); - System.out.println(te8.isLinearRightNormal()); - te8.selfLinearRightNormalize(); - System.out.println(te8.toStr()); - System.out.println(te8.isLinearRightNormal()); - + System.out.println(te5.toStr()); } diff --git a/src/models/AssignEvaluableTerm.java b/src/models/AssignEvaluableTerm.java deleted file mode 100644 index 046fce1..0000000 --- a/src/models/AssignEvaluableTerm.java +++ /dev/null @@ -1,109 +0,0 @@ -package models; - -import lombok.Getter; -import lombok.Setter; - -@Getter -@Setter -public class AssignEvaluableTerm extends EvaluableTerm{ - - private EvaluableTerm term; - private RDLVariable variable; - private EvaluableTerm valueTerm; - - public AssignEvaluableTerm(int order) { - super(order); - } - - public AssignEvaluableTerm(EvaluableTerm term, RDLVariable variable, EvaluableTerm valueTerm) { - super(variable.getOrder() - 1); - this.term = term; - this.variable = variable; - this.valueTerm = valueTerm; - } - - @Override - public boolean isLinearRightNormal() { - return isLinearRightNormal(0); - } - - @Override - public EvaluableTerm linearRightNormalize() { - AssignEvaluableTerm newTerm = new AssignEvaluableTerm(term ,variable, valueTerm); - newTerm.selfLinearRightNormalize(); - return newTerm; - } - - @Override - public int getOrder() { - if(variable.getOrder() == valueTerm.getOrder()) { - return variable.getOrder(); - } else { - return variable.getOrder() - 1; - } - } - - @Override - public void selfLinearRightNormalize() { - if(term instanceof RDLVariable || term instanceof SetEvaluableTerm) { - valueTerm.selfLinearRightNormalize(); - return; - } - AssignEvaluableTerm term = (AssignEvaluableTerm) this.term; - if(! term.isLinearRightNormal()) { - term.selfLinearRightNormalize(); - } - if(! isLinearRightNormal()) { - EvaluableTerm childTerm = term.getTerm(); - RDLVariable childVariable = term.getVariable(); - EvaluableTerm childValueTerm = term.getValueTerm(); - AssignEvaluableTerm newValueTerm = new AssignEvaluableTerm(childValueTerm, this.variable, this.valueTerm); - this.term = childTerm; - this.variable = childVariable; - this.valueTerm = newValueTerm; - - } - valueTerm.selfLinearRightNormalize(); - - } - - private boolean isLinearRightNormal(int depth) { - if(term instanceof RDLVariable || term instanceof SetEvaluableTerm) { - return term.getOrder() == variable.getOrder(); - } - AssignEvaluableTerm term = (AssignEvaluableTerm) this.term; - if( - term.isLinearRightNormal(depth + 1) && - term.getVariable().getOrder() - 1 == variable.getOrder() && - term.getOrder() == variable.getOrder() && - valueTerm.getOrder() <= term.getOrder() && - depth == 0 - ) { - return true; - } - if( - term.isLinearRightNormal(depth + 1) && - term.getVariable().getOrder() - 1 == variable.getOrder() && - term.getOrder() == variable.getOrder() && - valueTerm.getOrder() < term.getOrder() - ) { - return true; - } - - return false; - } - - @Override - public String toStr() { - StringBuilder sb = new StringBuilder(); - sb.append('['); - sb.append(term.toStr()); - sb.append(" : "); - sb.append(variable.toStr()); - sb.append(" -> "); - sb.append(valueTerm.toStr()); - sb.append(']'); - return sb.toString(); - } - -} diff --git a/src/models/Dependency.java b/src/models/Dependency.java index 84b0ca0..bfefc35 100644 --- a/src/models/Dependency.java +++ b/src/models/Dependency.java @@ -1,40 +1,44 @@ package models; import lombok.Getter; -import lombok.Setter; @Getter -@Setter public class Dependency extends RDLTerm{ - private RDLTerm term; - private RDLVariable variable; + private RDLTerm dependingTerm; + private ResourceVariable dependedVariable; private Dependency dependency; - public Dependency(RDLTerm term, RDLVariable variable) { - super(variable.getOrder()); - this.term = term; - this.variable = variable; + public Dependency(RDLTerm dependingTerm, ResourceVariable dependedVariable) { + super(dependedVariable.getOrder()); + this.dependingTerm = dependingTerm; + this.dependedVariable = dependedVariable; this.dependency = null; + this.addChild(dependingTerm); + this.addChild(dependedVariable); } public Dependency(Dependency dependency) { super(dependency.getOrder() - 1); this.dependency = dependency; - this.term = null; - this.variable = null; + this.dependingTerm = null; + this.dependedVariable = null; + this.addChild(dependency); } - public Dependency(RDLTerm term, RDLVariable variable, int order) { + public Dependency(RDLTerm dependingTerm, ResourceVariable dependedVariable, int order) { super(order); - if(order == variable.order) { - this.term = term; - this.variable = variable; + if(order == dependedVariable.order) { + this.dependingTerm = dependingTerm; + this.dependedVariable = dependedVariable; + this.addChild(dependingTerm); + this.addChild(dependedVariable); this.dependency = null; } else { - this.dependency = new Dependency(term, variable, order+1); - this.term = null; - this.variable = null; + this.dependency = new Dependency(dependingTerm, dependedVariable, order+1); + this.dependingTerm = null; + this.dependedVariable = null; + this.addChild(dependency); } } @@ -42,22 +46,20 @@ return this.dependency; } - public void setDependency(Dependency dependency) { - this.dependency = dependency; - } - @Override public int getTermOrder() { return getOrder() - 1; } + + @Override public String toStr() { StringBuilder sb = new StringBuilder(); if(dependency == null) { - sb.append(term.toStr()); + sb.append(dependingTerm.toStr()); sb.append(" : "); - sb.append(variable.toStr()); + sb.append(dependedVariable.toStr()); } else { sb.append('['); sb.append(dependency.toStr()); @@ -67,8 +69,28 @@ } @Override + public String toStrWithOrder() { + StringBuilder sb = new StringBuilder(); + if(dependency == null) { + sb.append(dependingTerm.toStrWithOrder()); + sb.append(" : "); + sb.append(dependedVariable.toStrWithOrder()); + } else { + sb.append('['); + sb.append(dependency.toStrWithOrder()); + sb.append(']'); + } + return sb.toString() + "(" + order + ")"; + } + + @Override public String toTermStr() { return "[" + toStr() + "]"; } + @Override + public Object clone() { + return new Dependency((RDLTerm) dependingTerm.clone(), (ResourceVariable) dependedVariable.clone()); + } + } diff --git a/src/models/DependencyTerm.java b/src/models/DependencyTerm.java new file mode 100644 index 0000000..ba31015 --- /dev/null +++ b/src/models/DependencyTerm.java @@ -0,0 +1,137 @@ +package models; + +import lombok.Getter; + +@Getter +public class DependencyTerm extends EvaluatableTerm{ + + private Dependency dependency; + private EvaluatableTerm argumentTerm; + + public DependencyTerm(int order) { + super(order); + } + + public DependencyTerm(Dependency dependency, EvaluatableTerm argumentTerm) { + super(dependency.getDependedVariable().getOrder() - 1); + this.dependency = dependency; + this.argumentTerm = argumentTerm; + this.addChild(dependency.getDependingTerm()); + this.addChild(dependency.getDependedVariable()); + this.addChild(argumentTerm); + } + + @Override + public boolean isLinearRightNormal() { + return isLinearRightNormal(0); + } + + @Override + public EvaluatableTerm linearRightNormalize() { + DependencyTerm newTerm = (DependencyTerm) clone(); + newTerm.selfLinearRightNormalize(); + return newTerm; + } + + @Override + public int getOrder() { + ResourceVariable variable = dependency.getDependedVariable(); + if(variable.getOrder() == argumentTerm.getOrder()) { + return variable.getOrder(); + } else { + return variable.getOrder() - 1; + } + } + + @Override + public void selfLinearRightNormalize() { + EvaluatableTerm term = (EvaluatableTerm) dependency.getDependingTerm(); //depending term. a of [a : b -> c] + if(term instanceof ResourceVariable || term instanceof SetEvaluatableTerm) { + argumentTerm.selfLinearRightNormalize(); + return; + } + DependencyTerm dependencyTerm = (DependencyTerm) term; + if(! dependencyTerm.isLinearRightNormal()) { + dependencyTerm.selfLinearRightNormalize(); + } + if(! isLinearRightNormal()) { + Dependency childDependency = dependencyTerm.getDependency(); + EvaluatableTerm childArgumentTerm = dependencyTerm.getArgumentTerm(); + Dependency nextDependency = new Dependency(childArgumentTerm, dependency.getDependedVariable()); + DependencyTerm nextDependencyTerm = new DependencyTerm(nextDependency, argumentTerm); + this.argumentTerm = nextDependencyTerm; + this.dependency = childDependency; + this.setChild(3, nextDependencyTerm); + this.setChild(0, childDependency.getChild(0)); + this.setChild(1, childDependency.getChild(1)); + } + argumentTerm.selfLinearRightNormalize(); + + } + + private boolean isLinearRightNormal(int depth) { + EvaluatableTerm term = (EvaluatableTerm) dependency.getDependingTerm(); //depending term. a of [a : b -> c] + ResourceVariable variable = dependency.getDependedVariable(); + if(term instanceof ResourceVariable || term instanceof SetEvaluatableTerm) { + return term.getOrder() == variable.getOrder(); + } + DependencyTerm dependencyTerm = (DependencyTerm) term; + if( + dependencyTerm.isLinearRightNormal(depth + 1) && + dependencyTerm.getDependency().getDependedVariable().getOrder() - 1 == variable.getOrder() && + dependencyTerm.getOrder() == variable.getOrder() && + argumentTerm.getOrder() <= dependencyTerm.getOrder() && + depth == 0 + ) { + return true; + } + if( + dependencyTerm.isLinearRightNormal(depth + 1) && + dependencyTerm.getDependency().getDependedVariable().getOrder() - 1 == variable.getOrder() && + dependencyTerm.getOrder() == variable.getOrder() && + argumentTerm.getOrder() < dependencyTerm.getOrder() + ) { + return true; + } + + return false; + } + + @Override + public String toStr() { + StringBuilder sb = new StringBuilder(); + sb.append('['); + sb.append(dependency.getDependingTerm().toStr()); + sb.append(" : "); + sb.append(dependency.getDependedVariable().toStr()); + sb.append(" -> "); + sb.append(argumentTerm.toStr()); + sb.append(']'); + return sb.toString(); + } + + @Override + public String toStrWithOrder() { + StringBuilder sb = new StringBuilder(); + sb.append('['); + sb.append(dependency.getDependingTerm().toStrWithOrder()); + sb.append(" : "); + sb.append(dependency.getDependedVariable().toStrWithOrder()); + sb.append(" -> "); + sb.append(argumentTerm.toStrWithOrder()); + sb.append(']'); + sb.append('('); + sb.append(order); + sb.append(')'); + return sb.toString(); + } + + @Override + public Object clone() { + return new DependencyTerm( + (Dependency) dependency.clone(), + (EvaluatableTerm) argumentTerm.clone() + ); + } + +} diff --git a/src/models/EvaluableTerm.java b/src/models/EvaluableTerm.java deleted file mode 100644 index a507854..0000000 --- a/src/models/EvaluableTerm.java +++ /dev/null @@ -1,39 +0,0 @@ -package models; - -import models.algebra.Type; - -public abstract class EvaluableTerm extends RDLTerm{ - - public EvaluableTerm(int order) { - super(order); - } - - public abstract boolean isLinearRightNormal(); - - @Deprecated - public abstract EvaluableTerm linearRightNormalize(); - public abstract void selfLinearRightNormalize(); - - public static RDLVariable of(String name, Type type, int order) { - return new RDLVariable(name, type, order); - } - - public static AssignEvaluableTerm of(EvaluableTerm term, RDLVariable variable, EvaluableTerm valueTerm) { - return new AssignEvaluableTerm(term, variable, valueTerm); - } - - public static EvaluableTerm of(EvaluableTerm term, RDLVariable variable, EvaluableTerm valueTerm, int order) { - if(variable.getOrder() == valueTerm.getOrder() && variable.getOrder() == order) { - return new AssignEvaluableTerm(term, variable, valueTerm); - } else if(variable.getOrder() -1 == order) { - return new AssignEvaluableTerm(term, variable, valueTerm); - } else { - return new SetEvaluableTerm(new AssignEvaluableTerm(term, variable, valueTerm), order); - } - } - - public static SetEvaluableTerm of(EvaluableTerm term, int order) { - return new SetEvaluableTerm(term, order); - } - -} diff --git a/src/models/EvaluatableTerm.java b/src/models/EvaluatableTerm.java new file mode 100644 index 0000000..e7c17c7 --- /dev/null +++ b/src/models/EvaluatableTerm.java @@ -0,0 +1,53 @@ +package models; + +import models.algebra.Type; + +public abstract class EvaluatableTerm extends RDLTerm{ + + public EvaluatableTerm(int order) { + super(order); + } + + public abstract boolean isLinearRightNormal(); + + 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(new Dependency(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(new Dependency(term, variable), valueTerm); + } else if(variable.getOrder() -1 == order) { + return new DependencyTerm(new Dependency(term, variable), valueTerm); + } else { + return new SetEvaluatableTerm(new DependencyTerm(new Dependency(term, variable), valueTerm), order); + } + } + + public static DependencyTerm of(Dependency dependency, EvaluatableTerm argumentTerm) { + return new DependencyTerm(dependency, argumentTerm); + } + + public static EvaluatableTerm of(Dependency dependency, EvaluatableTerm argumentTerm, int order) { + ResourceVariable variable = dependency.getDependedVariable(); + if(variable.getOrder() == argumentTerm.getOrder() && variable.getOrder() == order) { + return new DependencyTerm(dependency, argumentTerm); + } else if(variable.getOrder() - 1 == order) { + return new DependencyTerm(dependency, argumentTerm); + } else { + return new SetEvaluatableTerm(new DependencyTerm(dependency, argumentTerm), order); + } + } + + public static SetEvaluatableTerm of(EvaluatableTerm term, int order) { + return new SetEvaluatableTerm(term, order); + } + +} diff --git a/src/models/RDLConstant.java b/src/models/RDLConstant.java deleted file mode 100644 index 1cd4832..0000000 --- a/src/models/RDLConstant.java +++ /dev/null @@ -1,45 +0,0 @@ -package models; - -import lombok.Getter; -import lombok.Setter; -import models.algebra.Type; - -@Getter -@Setter -public class RDLConstant extends EvaluableTerm{ - - private String name; - private Type type; - - public RDLConstant(String name) { - super(0); - this.name = name; - this.type = null; - } - - public RDLConstant(String name, Type type) { - super(0); - this.name = name; - this.type = type; - } - - @Override - public boolean isLinearRightNormal() { - return true; - } - - @Override - public EvaluableTerm linearRightNormalize() { - return new RDLConstant(name, type); - } - - @Override - public void selfLinearRightNormalize() { - } - - @Override - public String toStr() { - return this.name; - } - -} diff --git a/src/models/RDLTerm.java b/src/models/RDLTerm.java index e3bcb6a..de37c7a 100644 --- a/src/models/RDLTerm.java +++ b/src/models/RDLTerm.java @@ -1,15 +1,16 @@ package models; import lombok.Getter; -import lombok.Setter; +import models.algebra.Symbol; +import models.algebra.Term; @Getter -@Setter -public abstract class RDLTerm{ +public abstract class RDLTerm extends Term{ protected int order; public RDLTerm(int order) { + super(new Symbol("aaa", 3)); this.order = order; } @@ -19,6 +20,8 @@ public abstract String toStr(); + public abstract String toStrWithOrder(); + public String toTermStr() { return toStr(); } diff --git a/src/models/RDLVariable.java b/src/models/RDLVariable.java deleted file mode 100644 index 3cc29cf..0000000 --- a/src/models/RDLVariable.java +++ /dev/null @@ -1,39 +0,0 @@ -package models; - -import lombok.Getter; -import lombok.Setter; -import models.algebra.Type; - -@Setter -@Getter -public class RDLVariable extends EvaluableTerm{ - - private String name; - private Type type; - - public RDLVariable(String name, Type type, int order) { - super(order); - this.name = name; - this.type = type; - } - - @Override - public EvaluableTerm linearRightNormalize() { - return new RDLVariable(name, type, order); - } - - @Override - public void selfLinearRightNormalize() { - } - - @Override - public boolean isLinearRightNormal() { - return true; - } - - @Override - public String toStr() { - return this.name; - } - -} diff --git a/src/models/ResourceConstant.java b/src/models/ResourceConstant.java new file mode 100644 index 0000000..010cb46 --- /dev/null +++ b/src/models/ResourceConstant.java @@ -0,0 +1,57 @@ +package models; + +import lombok.Getter; +import lombok.Setter; +import models.algebra.Type; + +@Getter +@Setter +public class ResourceConstant extends EvaluatableTerm{ + + private String name; + private Type type; + + public ResourceConstant(String name) { + super(0); + this.name = name; + this.type = null; + } + + public ResourceConstant(String name, Type type) { + super(0); + this.name = name; + this.type = type; + } + + @Override + public boolean isLinearRightNormal() { + return true; + } + + @Override + public EvaluatableTerm linearRightNormalize() { + return (ResourceConstant) clone(); + } + + @Override + public void selfLinearRightNormalize() { + } + + @Override + public String toStr() { + return this.name; + } + + @Override + public String toStrWithOrder() { + return this.name + "(" + order + ")"; + } + + @Override + public Object clone() { + return new ResourceConstant(name, type); + } + + + +} diff --git a/src/models/ResourceVariable.java b/src/models/ResourceVariable.java new file mode 100644 index 0000000..aa8a02b --- /dev/null +++ b/src/models/ResourceVariable.java @@ -0,0 +1,49 @@ +package models; + +import lombok.Getter; +import lombok.Setter; +import models.algebra.Type; + +@Setter +@Getter +public class ResourceVariable extends EvaluatableTerm{ + + private String name; + private Type type; + + public ResourceVariable(String name, Type type, int order) { + super(order); + this.name = name; + this.type = type; + } + + @Override + public EvaluatableTerm linearRightNormalize() { + return (ResourceVariable) clone(); + } + + @Override + public void selfLinearRightNormalize() { + } + + @Override + public boolean isLinearRightNormal() { + return true; + } + + @Override + public String toStr() { + return this.name; + } + + @Override + public String toStrWithOrder() { + return this.name + "(" + order + ")"; + } + + @Override + public Object clone() { + return new ResourceVariable(name, type, order); + } + +} diff --git a/src/models/SetEvaluableTerm.java b/src/models/SetEvaluableTerm.java deleted file mode 100644 index 97ff0aa..0000000 --- a/src/models/SetEvaluableTerm.java +++ /dev/null @@ -1,49 +0,0 @@ -package models; - -import lombok.Getter; -import lombok.Setter; - -@Getter -@Setter -public class SetEvaluableTerm extends EvaluableTerm{ - - private EvaluableTerm term; - - public SetEvaluableTerm(EvaluableTerm term) { - super(term.getOrder() - 1); - this.term = term; - } - - public SetEvaluableTerm(EvaluableTerm term, int order) { - super(order); - if(term.getOrder() > order + 1) { - this.term = new SetEvaluableTerm(term, order+1); - } else { - this.term = term; - } - } - - @Override - public EvaluableTerm linearRightNormalize() { - return new SetEvaluableTerm(term, order); - } - - @Override - public void selfLinearRightNormalize() { - } - - @Override - public boolean isLinearRightNormal() { - return term.isLinearRightNormal(); - } - - @Override - public String toStr() { - StringBuilder sb = new StringBuilder(); - sb.append('{'); - sb.append(term.toStr()); - sb.append('}'); - return sb.toString(); - } - -} diff --git a/src/models/SetEvaluatableTerm.java b/src/models/SetEvaluatableTerm.java new file mode 100644 index 0000000..a9ee787 --- /dev/null +++ b/src/models/SetEvaluatableTerm.java @@ -0,0 +1,67 @@ +package models; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class SetEvaluatableTerm extends EvaluatableTerm{ + + private EvaluatableTerm term; + + public SetEvaluatableTerm(EvaluatableTerm term) { + super(term.getOrder() - 1); + this.term = term; + this.addChild(term); + } + + public SetEvaluatableTerm(EvaluatableTerm term, int order) { + super(order); + if(term.getOrder() > order + 1) { + var childTerm = new SetEvaluatableTerm(term, order+1); + this.term = childTerm; + this.addChild(childTerm); + } else { + this.term = term; + this.addChild(term); + } + } + + @Override + public EvaluatableTerm linearRightNormalize() { + return (SetEvaluatableTerm) clone(); + } + + @Override + public void selfLinearRightNormalize() { + } + + @Override + public boolean isLinearRightNormal() { + return term.isLinearRightNormal(); + } + + @Override + public String toStr() { + StringBuilder sb = new StringBuilder(); + sb.append('{'); + sb.append(term.toStr()); + sb.append('}'); + return sb.toString(); + } + + @Override + public String toStrWithOrder() { + StringBuilder sb = new StringBuilder(); + sb.append('{'); + sb.append(term.toStrWithOrder()); + sb.append('}'); + return sb.toString() + "(" + order + ")"; + } + + @Override + public Object clone() { + return new SetEvaluatableTerm((EvaluatableTerm) term.clone(), order); + } + +} diff --git a/src/tests/LinearRightNormalTest.java b/src/tests/LinearRightNormalTest.java index 02f4662..498fa3a 100644 --- a/src/tests/LinearRightNormalTest.java +++ b/src/tests/LinearRightNormalTest.java @@ -4,8 +4,8 @@ import org.junit.jupiter.api.Test; -import models.EvaluableTerm; -import models.RDLVariable; +import models.EvaluatableTerm; +import models.ResourceVariable; import models.algebra.Type; import models.dataConstraintModel.DataConstraintModel; @@ -17,23 +17,23 @@ void linearRightNormalTest() { - RDLVariable a = EvaluableTerm.of("A", INT, 2); - RDLVariable b = EvaluableTerm.of("B", INT, 2); - RDLVariable c = EvaluableTerm.of("C", INT, 2); - RDLVariable d = EvaluableTerm.of("D", INT, 2); - RDLVariable e = EvaluableTerm.of("E", INT, 2); - RDLVariable f = EvaluableTerm.of("F", INT, 2); - RDLVariable g = EvaluableTerm.of("G", INT, 1); + 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); - EvaluableTerm te1 = EvaluableTerm.of(e, f, g); - EvaluableTerm te2 = EvaluableTerm.of(c, d, te1); - EvaluableTerm te3 = EvaluableTerm.of(a, b, te2); + EvaluatableTerm te1 = EvaluatableTerm.of(e, f, g); + EvaluatableTerm te2 = EvaluatableTerm.of(c, d, te1); + EvaluatableTerm te3 = EvaluatableTerm.of(a, b, te2); //[a:b->[c:d->[e:f->g]]] assertEquals(te3.isLinearRightNormal(), true); - EvaluableTerm te4 = EvaluableTerm.of(a, b, c); - EvaluableTerm te5 = EvaluableTerm.of(te4, d, e); - EvaluableTerm te6 = EvaluableTerm.of(te5, f, g); + EvaluatableTerm te4 = EvaluatableTerm.of(a, b, c); + EvaluatableTerm te5 = EvaluatableTerm.of(te4, d, e); + EvaluatableTerm te6 = EvaluatableTerm.of(te5, f, g); //[[[a:b->c]:d->e]:f->g] assertEquals(te6.isLinearRightNormal(), false); } @@ -41,17 +41,17 @@ @Test void linearRightNormalizeTest() { - RDLVariable a = EvaluableTerm.of("A", INT, 2); - RDLVariable b = EvaluableTerm.of("B", INT, 2); - RDLVariable c = EvaluableTerm.of("C", INT, 2); - RDLVariable d = EvaluableTerm.of("D", INT, 2); - RDLVariable e = EvaluableTerm.of("E", INT, 2); - RDLVariable f = EvaluableTerm.of("F", INT, 2); - RDLVariable g = EvaluableTerm.of("G", INT, 1); + 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); - EvaluableTerm te1 = EvaluableTerm.of(a, b, c); - EvaluableTerm te2 = EvaluableTerm.of(te1, d, e); - EvaluableTerm te3 = EvaluableTerm.of(te2, f, g); + EvaluatableTerm te1 = EvaluatableTerm.of(a, b, c); + EvaluatableTerm te2 = EvaluatableTerm.of(te1, d, e); + EvaluatableTerm te3 = EvaluatableTerm.of(te2, f, g); assertEquals(te3.isLinearRightNormal(), false); te3.selfLinearRightNormalize(); diff --git a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties index 15ddb74..fea17d2 100644 --- a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties +++ b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties @@ -1,5 +1,5 @@ #Generated by Maven Integration for Eclipse -#Sat Sep 20 18:22:07 JST 2025 +#Fri Sep 26 20:17:34 JST 2025 m2e.projectLocation=C\:\\pleiades\\2023-03\\myproject\\ResourceDependencyLogic m2e.projectName=ResourceDependencyLogic groupId=ResourceDependencyLogic diff --git a/target/classes/Main.class b/target/classes/Main.class index 20b8d82..ef4faad 100644 --- a/target/classes/Main.class +++ b/target/classes/Main.class Binary files differ diff --git a/target/classes/models/AssignEvaluableTerm.class b/target/classes/models/AssignEvaluableTerm.class deleted file mode 100644 index 300036a..0000000 --- a/target/classes/models/AssignEvaluableTerm.class +++ /dev/null Binary files differ diff --git a/target/classes/models/Dependency.class b/target/classes/models/Dependency.class index 4f019b9..9c879d5 100644 --- a/target/classes/models/Dependency.class +++ b/target/classes/models/Dependency.class Binary files differ diff --git a/target/classes/models/DependencyTerm.class b/target/classes/models/DependencyTerm.class new file mode 100644 index 0000000..535436b --- /dev/null +++ b/target/classes/models/DependencyTerm.class Binary files differ diff --git a/target/classes/models/EvaluableTerm.class b/target/classes/models/EvaluableTerm.class deleted file mode 100644 index 517f948..0000000 --- a/target/classes/models/EvaluableTerm.class +++ /dev/null Binary files differ diff --git a/target/classes/models/EvaluatableTerm.class b/target/classes/models/EvaluatableTerm.class new file mode 100644 index 0000000..9ba4ef6 --- /dev/null +++ b/target/classes/models/EvaluatableTerm.class Binary files differ diff --git a/target/classes/models/RDLConstant.class b/target/classes/models/RDLConstant.class deleted file mode 100644 index d6693ef..0000000 --- a/target/classes/models/RDLConstant.class +++ /dev/null Binary files differ diff --git a/target/classes/models/RDLTerm.class b/target/classes/models/RDLTerm.class index f8fdff7..d032fec 100644 --- a/target/classes/models/RDLTerm.class +++ b/target/classes/models/RDLTerm.class Binary files differ diff --git a/target/classes/models/RDLVariable.class b/target/classes/models/RDLVariable.class deleted file mode 100644 index 4531930..0000000 --- a/target/classes/models/RDLVariable.class +++ /dev/null Binary files differ diff --git a/target/classes/models/ResourceConstant.class b/target/classes/models/ResourceConstant.class new file mode 100644 index 0000000..26777fd --- /dev/null +++ b/target/classes/models/ResourceConstant.class Binary files differ diff --git a/target/classes/models/ResourceVariable.class b/target/classes/models/ResourceVariable.class new file mode 100644 index 0000000..b56168a --- /dev/null +++ b/target/classes/models/ResourceVariable.class Binary files differ diff --git a/target/classes/models/SetEvaluableTerm.class b/target/classes/models/SetEvaluableTerm.class deleted file mode 100644 index 9ccef33..0000000 --- a/target/classes/models/SetEvaluableTerm.class +++ /dev/null Binary files differ diff --git a/target/classes/models/SetEvaluatableTerm.class b/target/classes/models/SetEvaluatableTerm.class new file mode 100644 index 0000000..5e8fd02 --- /dev/null +++ b/target/classes/models/SetEvaluatableTerm.class Binary files differ diff --git a/target/classes/tests/LinearRightNormalTest.class b/target/classes/tests/LinearRightNormalTest.class index 784265a..ec019b6 100644 --- a/target/classes/tests/LinearRightNormalTest.class +++ b/target/classes/tests/LinearRightNormalTest.class Binary files differ