diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..7904408 --- /dev/null +++ b/.classpath @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..e5ae7d2 --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + ResourceDependencyLogic + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..43c8d71 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,15 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=17 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..f897a7f --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/bin/Main.class b/bin/Main.class new file mode 100644 index 0000000..b25c141 --- /dev/null +++ b/bin/Main.class Binary files differ diff --git a/bin/models/Dependency.class b/bin/models/Dependency.class new file mode 100644 index 0000000..62d1839 --- /dev/null +++ b/bin/models/Dependency.class Binary files differ diff --git a/bin/models/EvaluableTerm.class b/bin/models/EvaluableTerm.class new file mode 100644 index 0000000..135be5b --- /dev/null +++ b/bin/models/EvaluableTerm.class Binary files differ diff --git a/bin/models/RDLConstant.class b/bin/models/RDLConstant.class new file mode 100644 index 0000000..12de35c --- /dev/null +++ b/bin/models/RDLConstant.class Binary files differ diff --git a/bin/models/RDLTerm.class b/bin/models/RDLTerm.class new file mode 100644 index 0000000..59a825b --- /dev/null +++ b/bin/models/RDLTerm.class Binary files differ diff --git a/bin/models/RDLVariable.class b/bin/models/RDLVariable.class new file mode 100644 index 0000000..242a007 --- /dev/null +++ b/bin/models/RDLVariable.class Binary files differ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..16b3e9a --- /dev/null +++ b/pom.xml @@ -0,0 +1,43 @@ + + 4.0.0 + ResourceDependencyLogic + ResourceDependencyLogic + 0.0.1-SNAPSHOT + + + + org.projectlombok + lombok + 1.18.34 + provided + + + + org.junit.jupiter + junit-jupiter + 5.11.3 + test + + + + + src + + + + maven-compiler-plugin + 3.8.1 + + 17 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + + \ No newline at end of file diff --git a/src/Main.java b/src/Main.java new file mode 100644 index 0000000..d79a6cb --- /dev/null +++ b/src/Main.java @@ -0,0 +1,48 @@ +import models.EvaluableTerm; +import models.RDLVariable; +import models.algebra.Type; +import models.dataConstraintModel.DataConstraintModel; + +public class Main { + + public static void main(String[] args) { + + 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); + + 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); + + System.out.println(te4.toStr()); + 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()); + + + } + +} diff --git a/src/models/AssignEvaluableTerm.java b/src/models/AssignEvaluableTerm.java new file mode 100644 index 0000000..046fce1 --- /dev/null +++ b/src/models/AssignEvaluableTerm.java @@ -0,0 +1,109 @@ +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 new file mode 100644 index 0000000..84b0ca0 --- /dev/null +++ b/src/models/Dependency.java @@ -0,0 +1,74 @@ +package models; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class Dependency extends RDLTerm{ + + private RDLTerm term; + private RDLVariable variable; + private Dependency dependency; + + public Dependency(RDLTerm term, RDLVariable variable) { + super(variable.getOrder()); + this.term = term; + this.variable = variable; + this.dependency = null; + } + + public Dependency(Dependency dependency) { + super(dependency.getOrder() - 1); + this.dependency = dependency; + this.term = null; + this.variable = null; + } + + public Dependency(RDLTerm term, RDLVariable variable, int order) { + super(order); + if(order == variable.order) { + this.term = term; + this.variable = variable; + this.dependency = null; + } else { + this.dependency = new Dependency(term, variable, order+1); + this.term = null; + this.variable = null; + } + } + + public Dependency getDependency() { + 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(" : "); + sb.append(variable.toStr()); + } else { + sb.append('['); + sb.append(dependency.toStr()); + sb.append(']'); + } + return sb.toString(); + } + + @Override + public String toTermStr() { + return "[" + toStr() + "]"; + } + +} diff --git a/src/models/EvaluableTerm.java b/src/models/EvaluableTerm.java new file mode 100644 index 0000000..a507854 --- /dev/null +++ b/src/models/EvaluableTerm.java @@ -0,0 +1,39 @@ +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/RDLConstant.java b/src/models/RDLConstant.java new file mode 100644 index 0000000..1cd4832 --- /dev/null +++ b/src/models/RDLConstant.java @@ -0,0 +1,45 @@ +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 new file mode 100644 index 0000000..e3bcb6a --- /dev/null +++ b/src/models/RDLTerm.java @@ -0,0 +1,26 @@ +package models; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public abstract class RDLTerm{ + + protected int order; + + public RDLTerm(int order) { + this.order = order; + } + + public int getTermOrder() { + return getOrder(); + } + + public abstract String toStr(); + + public String toTermStr() { + return toStr(); + } + +} diff --git a/src/models/RDLVariable.java b/src/models/RDLVariable.java new file mode 100644 index 0000000..3cc29cf --- /dev/null +++ b/src/models/RDLVariable.java @@ -0,0 +1,39 @@ +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/SetEvaluableTerm.java b/src/models/SetEvaluableTerm.java new file mode 100644 index 0000000..97ff0aa --- /dev/null +++ b/src/models/SetEvaluableTerm.java @@ -0,0 +1,49 @@ +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/tests/LinearRightNormalTest.java b/src/tests/LinearRightNormalTest.java new file mode 100644 index 0000000..02f4662 --- /dev/null +++ b/src/tests/LinearRightNormalTest.java @@ -0,0 +1,61 @@ +package tests; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +import models.EvaluableTerm; +import models.RDLVariable; +import models.algebra.Type; +import models.dataConstraintModel.DataConstraintModel; + +public class LinearRightNormalTest { + + Type INT = DataConstraintModel.typeInt; + + @Test + 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); + + EvaluableTerm te1 = EvaluableTerm.of(e, f, g); + EvaluableTerm te2 = EvaluableTerm.of(c, d, te1); + EvaluableTerm te3 = EvaluableTerm.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); + //[[[a:b->c]:d->e]:f->g] + assertEquals(te6.isLinearRightNormal(), false); + } + + @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); + + EvaluableTerm te1 = EvaluableTerm.of(a, b, c); + EvaluableTerm te2 = EvaluableTerm.of(te1, d, e); + EvaluableTerm te3 = EvaluableTerm.of(te2, f, g); + + assertEquals(te3.isLinearRightNormal(), false); + te3.selfLinearRightNormalize(); + assertEquals(te3.isLinearRightNormal(), true); + } + +} diff --git a/target/classes/META-INF/MANIFEST.MF b/target/classes/META-INF/MANIFEST.MF new file mode 100644 index 0000000..6ea90ca --- /dev/null +++ b/target/classes/META-INF/MANIFEST.MF @@ -0,0 +1,5 @@ +Manifest-Version: 1.0 +Built-By: takot +Build-Jdk: 17.0.10 +Created-By: Maven Integration for Eclipse + diff --git a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties new file mode 100644 index 0000000..15ddb74 --- /dev/null +++ b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties @@ -0,0 +1,7 @@ +#Generated by Maven Integration for Eclipse +#Sat Sep 20 18:22:07 JST 2025 +m2e.projectLocation=C\:\\pleiades\\2023-03\\myproject\\ResourceDependencyLogic +m2e.projectName=ResourceDependencyLogic +groupId=ResourceDependencyLogic +artifactId=ResourceDependencyLogic +version=0.0.1-SNAPSHOT diff --git a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.xml b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.xml new file mode 100644 index 0000000..16b3e9a --- /dev/null +++ b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.xml @@ -0,0 +1,43 @@ + + 4.0.0 + ResourceDependencyLogic + ResourceDependencyLogic + 0.0.1-SNAPSHOT + + + + org.projectlombok + lombok + 1.18.34 + provided + + + + org.junit.jupiter + junit-jupiter + 5.11.3 + test + + + + + src + + + + maven-compiler-plugin + 3.8.1 + + 17 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + + \ No newline at end of file diff --git a/target/classes/Main.class b/target/classes/Main.class new file mode 100644 index 0000000..20b8d82 --- /dev/null +++ b/target/classes/Main.class Binary files differ diff --git a/target/classes/models/AssignEvaluableTerm.class b/target/classes/models/AssignEvaluableTerm.class new file mode 100644 index 0000000..300036a --- /dev/null +++ b/target/classes/models/AssignEvaluableTerm.class Binary files differ diff --git a/target/classes/models/Dependency.class b/target/classes/models/Dependency.class new file mode 100644 index 0000000..4f019b9 --- /dev/null +++ b/target/classes/models/Dependency.class Binary files differ diff --git a/target/classes/models/EvaluableTerm.class b/target/classes/models/EvaluableTerm.class new file mode 100644 index 0000000..517f948 --- /dev/null +++ b/target/classes/models/EvaluableTerm.class Binary files differ diff --git a/target/classes/models/RDLConstant.class b/target/classes/models/RDLConstant.class new file mode 100644 index 0000000..d6693ef --- /dev/null +++ b/target/classes/models/RDLConstant.class Binary files differ diff --git a/target/classes/models/RDLTerm.class b/target/classes/models/RDLTerm.class new file mode 100644 index 0000000..f8fdff7 --- /dev/null +++ b/target/classes/models/RDLTerm.class Binary files differ diff --git a/target/classes/models/RDLVariable.class b/target/classes/models/RDLVariable.class new file mode 100644 index 0000000..4531930 --- /dev/null +++ b/target/classes/models/RDLVariable.class Binary files differ diff --git a/target/classes/models/SetEvaluableTerm.class b/target/classes/models/SetEvaluableTerm.class new file mode 100644 index 0000000..9ccef33 --- /dev/null +++ b/target/classes/models/SetEvaluableTerm.class Binary files differ diff --git a/target/classes/tests/LinearRightNormalTest.class b/target/classes/tests/LinearRightNormalTest.class new file mode 100644 index 0000000..784265a --- /dev/null +++ b/target/classes/tests/LinearRightNormalTest.class Binary files differ