From 14d13e62a9fe58a19efa7b889ac3ff73c34382ee Mon Sep 17 00:00:00 2001 From: Lorenz Leutgeb Date: Thu, 2 Dec 2021 21:48:31 +0100 Subject: [PATCH 01/96] repo: Migrate to Java 17 --- .github/workflows/build.yml | 13 +++---------- .../kotlin/alpha.java-common-conventions.gradle.kts | 4 ++-- 2 files changed, 5 insertions(+), 12 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1902bcbfe..90e393fa2 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -6,27 +6,20 @@ jobs: strategy: matrix: # We test against Java releases: - # - greater than 7 + # - greater than or equal to 17 # AND # - with LTS and in "Premier Support" phase # OR # - not succeeded by any other release - # No Oracle JDK >11, see - # https://blogs.oracle.com/java-platform-group/oracle-jdk-releases-for-java-11-and-later - # https://www.oracle.com/technetwork/java/java-se-support-roadmap.html java: - # LTS and in "Premier Support" as of 2019-03 (until 2022-03) - - 8 - # LTS and in "Premier Support" as of 2019-03 (until 2023-09) - - 11 - # LTS as of 2021-11 (until 2029) + # LTS as of 2021-12 (until 2029) - 17 os: [ubuntu, windows] env: # We only post coverage data for exactly one build to coveralls. # To pick that build from the build matrix, we designate one # Java version to be the "main" one. - MAIN_JAVA: 11 + MAIN_JAVA: 17 # We only post coverage data for exactly one build to coveralls. # To pick that build from the build matrix, we designate one # OS to be the "main" one. diff --git a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts index 79f6bef04..37cd44dca 100644 --- a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts @@ -12,8 +12,8 @@ repositories { mavenCentral { metadataSources { mavenPom() } } } -java.sourceCompatibility = JavaVersion.VERSION_1_8 -java.targetCompatibility = JavaVersion.VERSION_1_8 +java.sourceCompatibility = JavaVersion.VERSION_17 +java.targetCompatibility = JavaVersion.VERSION_17 dependencies { implementation("org.apache.commons:commons-collections4:4.4") From c6f79bec104ff7b680ca8b686711a5315c9d4938 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 15 Dec 2021 14:25:39 +0100 Subject: [PATCH 02/96] implementation skeleton for reification helper --- .../programs/literals/ComparisonLiteral.java | 2 +- .../alpha/api/programs/literals/Literal.java | 1 + .../at/ac/tuwien/kr/alpha/api/rules/Rule.java | 4 +- .../tuwien/kr/alpha/api/rules/heads/Head.java | 1 + .../commons/programs/ReificationHelper.java | 61 +++++++++++++++++++ 5 files changed, 67 insertions(+), 2 deletions(-) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java index 01b7d6075..5abf83c95 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs.literals; -public interface ComparisonLiteral extends Literal, FixedInterpretationLiteral { +public interface ComparisonLiteral extends FixedInterpretationLiteral { boolean isLeftOrRightAssigning(); diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java index 13b4dac0c..020376893 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java @@ -17,6 +17,7 @@ */ // TODO go through implementations and pull out stuff that can be default-implemented here public interface Literal { + Atom getAtom(); boolean isNegated(); diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java index 4f3013a86..f3b5a028b 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java @@ -8,7 +8,8 @@ /** * A rule as defined in the ASP Core 2 Standard. * - * @param the type of rule head (e.g. choice, normal, disjunctive) supported by a specific rule. + * @param the type of rule head (e.g. choice, normal, disjunctive) supported + * by a specific rule. * Copyright (c) 2021, the Alpha Team. */ public interface Rule { @@ -22,4 +23,5 @@ public interface Rule { Set getPositiveBody(); Set getNegativeBody(); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java index 4fb9e365b..909db79fc 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java @@ -6,4 +6,5 @@ * Copyright (c) 2021, the Alpha Team. */ public interface Head { + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java new file mode 100644 index 000000000..e29e2cf3c --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -0,0 +1,61 @@ +package at.ac.tuwien.kr.alpha.commons.programs; + +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.function.Supplier; + +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +public class ReificationHelper { + + private final Supplier> idProvider; + + public ReificationHelper(Supplier> idProvider) { + this.idProvider = idProvider; + } + + public Set reifyProgram(ASPCore2Program program) { + Set reified = new LinkedHashSet<>(); + for (Rule rule : program.getRules()) { + reified.addAll(reifyRule(rule)); + } + return reified; + } + + public Set reifyRule(Rule rule) { + Set reified = new LinkedHashSet<>(); + reified.addAll(reifyHead(rule.getHead())); + for (Literal lit : rule.getBody()) { + reified.addAll(reifyLiteral(lit)); + } + return null; + } + + public Set reifyHead(Head head) { + // TODO + return null; + } + + public Set reifyLiteral(Literal lit) { + // TODO + return null; + } + + public Set reifyAtom(Atom atom) { + // TODO + return null; + } + + public Set reifyTerm(Term term) { + // TODO + return null; + } + +} From 6a888da1bfea98614f2607733f3b01712cd30af9 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 17 Dec 2021 02:49:27 +0100 Subject: [PATCH 03/96] commons: draft implementation of reification logic for asp programs --- .../commons/programs/ReificationHelper.java | 383 +++++++++++++++++- 1 file changed, 367 insertions(+), 16 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index e29e2cf3c..352629acb 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -1,22 +1,168 @@ package at.ac.tuwien.kr.alpha.commons.programs; +import java.util.HashMap; import java.util.LinkedHashSet; +import java.util.Map; import java.util.Set; import java.util.function.Supplier; +import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; public class ReificationHelper { + // Predicates describing rules. + static final Predicate RULE = Predicates.getPredicate("rule", 1); + static final Predicate RULE_HEAD = Predicates.getPredicate("rule_head", 2); + static final Predicate RULE_BODY_LITERAL = Predicates.getPredicate("rule_bodyLiteral", 2); + + // Predicates describing heads. + static final Predicate HEAD_TYPE = Predicates.getPredicate("head_type", 2); + + // Predicates describing normal heads. + static final Predicate NORMAL_HEAD_ATOM = Predicates.getPredicate("normalHead_atom", 2); + + // Predicates describing choice heads. + static final Predicate CHOICE_HEAD_LOWER_BOUND = Predicates.getPredicate("choiceHead_lowerBound", 2); + static final Predicate CHOICE_HEAD_UPPER_BOUND = Predicates.getPredicate("choiceHead_upperBound", 2); + static final Predicate CHOICE_HEAD_ELEMENT = Predicates.getPredicate("choiceHead_element", 2); + static final Predicate CHOICE_ELEMENT_ATOM = Predicates.getPredicate("choiceElement_atom", 2); + static final Predicate CHOICE_ELEMENT_CONDITION_LITERAL = Predicates.getPredicate("choiceElement_conditionLiteral", 2); + + // Predicates describing literals. + static final Predicate LITERAL_POLARITY = Predicates.getPredicate("literal_polarity", 2); + static final Predicate LITERAL_ATOM = Predicates.getPredicate("literal_atom", 2); + + // Predicates describing predicates. + static final Predicate PREDICATE = Predicates.getPredicate("predicate", 3); + + // Predicates describing atoms. + static final Predicate ATOM_TYPE = Predicates.getPredicate("atom_type", 2); + + // Predicates describing basic atoms. + static final Predicate BASIC_ATOM_PREDICATE = Predicates.getPredicate("basicAtom_predicate", 2); + static final Predicate BASIC_ATOM_TERM = Predicates.getPredicate("basicAtom_term", 3); + + // Predicates describing comparison atoms. + static final Predicate COMPARISON_ATOM_LEFT = Predicates.getPredicate("comparisonAtom_leftTerm", 2); + static final Predicate COMPARISON_ATOM_RIGHT = Predicates.getPredicate("comparisonAtom_rightTerm", 2); + static final Predicate COMPARISON_ATOM_OPERATOR = Predicates.getPredicate("comparisonAtom_operator", 2); + + // Predicates describing external atoms. + static final Predicate EXTERNAL_ATOM_NAME = Predicates.getPredicate("externalAtom_name", 2); + static final Predicate EXTERNAL_ATOM_INPUT_TERM = Predicates.getPredicate("externalAtom_inputTerm", 3); + static final Predicate EXTERNAL_ATOM_OUTPUT_TERM = Predicates.getPredicate("externalAtom_outputTerm", 3); + + // Predicates describing aggregate atoms. + static final Predicate AGGREGATE_ATOM_LEFT_TERM = Predicates.getPredicate("aggregateAtom_leftHandTerm", 2); + static final Predicate AGGREGATE_ATOM_LEFT_OPERATOR = Predicates.getPredicate("aggregateAtom_leftHandOperator", 2); + static final Predicate AGGREGATE_ATOM_RIGHT_TERM = Predicates.getPredicate("aggregateAtom_rightHandTerm", 2); + static final Predicate AGGREGATE_ATOM_RIGHT_OPERATOR = Predicates.getPredicate("aggregateAtom_rightHandOperator", 2); + static final Predicate AGGREGATE_ATOM_AGGREGATE_FUNCTION = Predicates.getPredicate("aggregateAtom_aggregateFunction", 2); + static final Predicate AGGREGATE_ATOM_AGGREGATE_ELEMENT = Predicates.getPredicate("aggregateAtom_aggregateElement", 2); + + // Predicates describing aggregate elements. + static final Predicate AGGREGATE_ELEMENT_TERM = Predicates.getPredicate("aggregateElement_term", 3); + static final Predicate AGGREGATE_ELEMENT_LITERAL = Predicates.getPredicate("aggregateElement_literal", 2); + + // Predicates describing terms. + static final Predicate TERM_TYPE = Predicates.getPredicate("term_type", 2); + + // Predicates describing constant terms. + static final Predicate CONSTANT_TERM_CLASS = Predicates.getPredicate("constantTerm_class", 2); + static final Predicate CONSTANT_TERM_SYMBOLIC = Predicates.getPredicate("constantTerm_symbolic", 2); + static final Predicate CONSTANT_TERM_VALUE = Predicates.getPredicate("constantTerm_value", 2); + + // Predicates describing variable terms. + static final Predicate VARIABLE_TERM_SYMBOL = Predicates.getPredicate("variableTerm_symbol", 2); + + // Predicates describing arithmetic terms. + static final Predicate ARITHMETIC_TERM_LEFT = Predicates.getPredicate("arithmeticTerm_leftTerm", 2); + static final Predicate ARITHMETIC_TERM_RIGHT = Predicates.getPredicate("arithmeticTerm_rightTerm", 2); + static final Predicate ARITHMETIC_TERM_OPERATOR = Predicates.getPredicate("arithmeticTerm_operator", 2); + + // Predicates describing function terms. + static final Predicate FUNCTION_TERM_SYMBOL = Predicates.getPredicate("functionTerm_symbol", 2); + static final Predicate FUNCTION_TERM_ARGUMENT = Predicates.getPredicate("functionTerm_argumentTerm", 3); + + // Constants describing head types. + static final ConstantTerm HEAD_TYPE_NORMAL = Terms.newSymbolicConstant("normal"); + static final ConstantTerm HEAD_TYPE_CHOICE = Terms.newSymbolicConstant("choice"); + + // Constants describing literal polaritites. + static final ConstantTerm LITERAL_POLARITY_POSITIVE = Terms.newSymbolicConstant("pos"); + static final ConstantTerm LITERAL_POLARITY_NEGATIVE = Terms.newSymbolicConstant("neg"); + + // Constants describing atom types. + static final ConstantTerm ATOM_TYPE_BASIC = Terms.newSymbolicConstant("basic"); + static final ConstantTerm ATOM_TYPE_COMPARISON = Terms.newSymbolicConstant("comparison"); + static final ConstantTerm ATOM_TYPE_EXTERNAL = Terms.newSymbolicConstant("external"); + static final ConstantTerm ATOM_TYPE_AGGREGATE = Terms.newSymbolicConstant("aggregate"); + + // Constants describing comparison operators. + static final ConstantTerm CMP_OP_EQ = Terms.newSymbolicConstant("eq"); + static final ConstantTerm CMP_OP_NE = Terms.newSymbolicConstant("ne"); + static final ConstantTerm CMP_OP_LE = Terms.newSymbolicConstant("le"); + static final ConstantTerm CMP_OP_LT = Terms.newSymbolicConstant("lt"); + static final ConstantTerm CMP_OP_GE = Terms.newSymbolicConstant("ge"); + static final ConstantTerm CMP_OP_GT = Terms.newSymbolicConstant("gt"); + + // Constants describing aggregate functions. + static final ConstantTerm AGGREGATE_FUNCTION_COUNT = Terms.newSymbolicConstant("count"); + static final ConstantTerm AGGREGATE_FUNCTION_SUM = Terms.newSymbolicConstant("sum"); + static final ConstantTerm AGGREGATE_FUNCTION_MIN = Terms.newSymbolicConstant("min"); + static final ConstantTerm AGGREGATE_FUNCTION_MAX = Terms.newSymbolicConstant("max"); + + // Constants describing term types. + static final ConstantTerm TERM_TYPE_CONSTANT = Terms.newSymbolicConstant("constant"); + static final ConstantTerm TERM_TYPE_VARIABLE = Terms.newSymbolicConstant("variable"); + static final ConstantTerm TERM_TYPE_ARITHMETIC = Terms.newSymbolicConstant("arithmetic"); + static final ConstantTerm TERM_TYPE_FUNCTION = Terms.newSymbolicConstant("function"); + + private static final Map> CMP_OPS = new HashMap<>(); + private static final Map> AGG_FUNCS = new HashMap<>(); + + static { + CMP_OPS.put(ComparisonOperators.EQ, CMP_OP_EQ); + CMP_OPS.put(ComparisonOperators.NE, CMP_OP_NE); + CMP_OPS.put(ComparisonOperators.LE, CMP_OP_LE); + CMP_OPS.put(ComparisonOperators.LT, CMP_OP_LT); + CMP_OPS.put(ComparisonOperators.GE, CMP_OP_GE); + CMP_OPS.put(ComparisonOperators.GT, CMP_OP_GT); + + AGG_FUNCS.put(AggregateFunctionSymbol.COUNT, AGGREGATE_FUNCTION_COUNT); + AGG_FUNCS.put(AggregateFunctionSymbol.SUM, AGGREGATE_FUNCTION_SUM); + AGG_FUNCS.put(AggregateFunctionSymbol.MIN, AGGREGATE_FUNCTION_MIN); + AGG_FUNCS.put(AggregateFunctionSymbol.MAX, AGGREGATE_FUNCTION_MAX); + } + private final Supplier> idProvider; + private final Map> reifiedPredicates = new HashMap<>(); + public ReificationHelper(Supplier> idProvider) { this.idProvider = idProvider; } @@ -26,36 +172,241 @@ public Set reifyProgram(ASPCore2Program program) { for (Rule rule : program.getRules()) { reified.addAll(reifyRule(rule)); } + // TODO add reified predicate info return reified; } - public Set reifyRule(Rule rule) { + Set reifyRule(Rule rule) { Set reified = new LinkedHashSet<>(); - reified.addAll(reifyHead(rule.getHead())); + ConstantTerm ruleId = idProvider.get(); + reified.add(Atoms.newBasicAtom(RULE, ruleId)); + reified.addAll(reifyHead(ruleId, rule.getHead())); for (Literal lit : rule.getBody()) { - reified.addAll(reifyLiteral(lit)); + ConstantTerm literalId = idProvider.get(); + reified.add(Atoms.newBasicAtom(RULE_BODY_LITERAL, ruleId, literalId)); + reified.addAll(reifyLiteral(literalId, lit)); } - return null; + return reified; } - public Set reifyHead(Head head) { - // TODO - return null; + Set reifyHead(ConstantTerm ruleId, Head head) { + Set reified = new LinkedHashSet<>(); + ConstantTerm headId = idProvider.get(); + reified.add(Atoms.newBasicAtom(RULE_HEAD, ruleId, headId)); + if (head instanceof NormalHead) { + reified.addAll(reifyNormalHead(headId, (NormalHead) head)); + } else if (head instanceof ChoiceHead) { + reified.addAll(reifyChoiceHead(headId, (ChoiceHead) head)); + } else { + throw new IllegalArgumentException("Head type " + head.getClass().getSimpleName() + " cannot be reified!"); + } + return reified; } - public Set reifyLiteral(Literal lit) { - // TODO - return null; + Set reifyNormalHead(ConstantTerm headId, NormalHead head) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_NORMAL)); + ConstantTerm atomId = idProvider.get(); + reified.add(Atoms.newBasicAtom(NORMAL_HEAD_ATOM, headId, atomId)); + reified.addAll(reifyAtom(atomId, head.getAtom())); + return reified; } - public Set reifyAtom(Atom atom) { - // TODO - return null; + Set reifyChoiceHead(ConstantTerm headId, ChoiceHead head) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_CHOICE)); + if (head.getLowerBound() != null) { + reified.add(Atoms.newBasicAtom(CHOICE_HEAD_LOWER_BOUND, headId, head.getLowerBound())); + } + if (head.getUpperBound() != null) { + reified.add(Atoms.newBasicAtom(CHOICE_HEAD_UPPER_BOUND, headId, head.getUpperBound())); + } + for (ChoiceElement element : head.getChoiceElements()) { + reified.addAll(reifyChoiceElement(headId, element)); + } + return reified; + } + + Set reifyChoiceElement(ConstantTerm headId, ChoiceElement element) { + Set reified = new LinkedHashSet<>(); + ConstantTerm elementId = idProvider.get(); + reified.add(Atoms.newBasicAtom(CHOICE_HEAD_ELEMENT, headId, elementId)); + ConstantTerm atomId = idProvider.get(); + reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_ATOM, elementId, atomId)); + reified.addAll(reifyAtom(atomId, element.getChoiceAtom())); + for (Literal lit : element.getConditionLiterals()) { + ConstantTerm literalId = idProvider.get(); + reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_CONDITION_LITERAL, elementId, literalId)); + reified.addAll(reifyLiteral(literalId, lit)); + } + return reified; } - public Set reifyTerm(Term term) { - // TODO - return null; + Set reifyLiteral(ConstantTerm literalId, Literal lit) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(LITERAL_POLARITY, literalId, lit.isNegated() ? LITERAL_POLARITY_NEGATIVE : LITERAL_POLARITY_POSITIVE)); + ConstantTerm atomId = idProvider.get(); + reified.add(Atoms.newBasicAtom(LITERAL_ATOM, literalId, atomId)); + reified.addAll(reifyAtom(atomId, lit.getAtom())); + return reified; + } + + Set reifyAtom(ConstantTerm atomId, Atom atom) { + if (atom instanceof BasicAtom) { + return reifyBasicAtom(atomId, (BasicAtom) atom); + } else if (atom instanceof ComparisonAtom) { + return reifyComparisonAtom(atomId, (ComparisonAtom) atom); + } else if (atom instanceof ExternalAtom) { + return reifyExternalAtom(atomId, (ExternalAtom) atom); + } else if (atom instanceof AggregateAtom) { + return reifyAggregateAtom(atomId, (AggregateAtom) atom); + } else { + throw new IllegalArgumentException("Atom type " + atom.getClass().getSimpleName() + " cannot be reified!"); + } + } + + Set reifyBasicAtom(ConstantTerm atomId, BasicAtom atom) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_BASIC)); + ConstantTerm predicateId; + if (reifiedPredicates.containsKey(atom.getPredicate())) { + predicateId = reifiedPredicates.get(atom.getPredicate()); + } else { + predicateId = idProvider.get(); + reifiedPredicates.put(atom.getPredicate(), predicateId); + } + reified.add(Atoms.newBasicAtom(BASIC_ATOM_PREDICATE, atomId, predicateId)); + for (int i = 0; i < atom.getTerms().size(); i++) { + ConstantTerm termId = idProvider.get(); + reified.add(Atoms.newBasicAtom(BASIC_ATOM_TERM, atomId, Terms.newConstant(i), termId)); + reified.addAll(reifyTerm(termId, atom.getTerms().get(i))); + } + return reified; + } + + Set reifyComparisonAtom(ConstantTerm atomId, ComparisonAtom atom) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_COMPARISON)); + ConstantTerm leftTermId = idProvider.get(); + ConstantTerm rightTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_LEFT, atomId, leftTermId)); + reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_RIGHT, atomId, rightTermId)); + if (!CMP_OPS.containsKey(atom.getOperator())) { + throw new IllegalArgumentException("Cannot reifiy comparison operator " + atom.getOperator()); + } + reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_OPERATOR, atomId, CMP_OPS.get(atom.getOperator()))); + reified.addAll(reifyTerm(leftTermId, atom.getTerms().get(0))); + reified.addAll(reifyTerm(rightTermId, atom.getTerms().get(1))); + return reified; + } + + Set reifyExternalAtom(ConstantTerm atomId, ExternalAtom atom) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_EXTERNAL)); + reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); + for (int i = 0; i < atom.getInput().size(); i++) { + ConstantTerm inTermId = idProvider.get(); + reified.addAll(reifyTerm(inTermId, atom.getInput().get(i))); + } + for (int i = 0; i < atom.getOutput().size(); i++) { + ConstantTerm outTermId = idProvider.get(); + reified.addAll(reifyTerm(outTermId, atom.getOutput().get(i))); + } + return reified; + } + + Set reifyAggregateAtom(ConstantTerm atomId, AggregateAtom atom) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_AGGREGATE)); + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_FUNCTION, atomId, AGG_FUNCS.get(atom.getAggregateFunction()))); + if (atom.getLowerBoundOperator() != null) { + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_OPERATOR, atomId, CMP_OPS.get(atom.getLowerBoundOperator()))); + ConstantTerm leftTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_TERM, atomId, leftTermId)); + } + if (atom.getUpperBoundOperator() != null) { + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_OPERATOR, atomId, CMP_OPS.get(atom.getUpperBoundOperator()))); + ConstantTerm rightTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_TERM, atomId, rightTermId)); + } + for (AggregateElement element : atom.getAggregateElements()) { + ConstantTerm elementId = idProvider.get(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_ELEMENT, atomId, elementId)); + reified.addAll(reifyAggregateElement(elementId, element)); + } + return reified; + } + + Set reifyAggregateElement(ConstantTerm elementId, AggregateElement element) { + Set reified = new LinkedHashSet<>(); + for (int i = 0; i < element.getElementTerms().size(); i++) { + ConstantTerm termId = idProvider.get(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_TERM, elementId, Terms.newConstant(i), termId)); + reified.addAll(reifyTerm(termId, element.getElementTerms().get(i))); + } + for (Literal lit : element.getElementLiterals()) { + ConstantTerm literalId = idProvider.get(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_LITERAL, elementId, literalId)); + reified.addAll(reifyLiteral(literalId, lit)); + } + return reified; + } + + Set reifyTerm(ConstantTerm termId, Term term) { + if (term instanceof ConstantTerm) { + return reifyConstantTerm(termId, (ConstantTerm) term); + } else if (term instanceof VariableTerm) { + return reifyVariableTerm(termId, (VariableTerm) term); + } else if (term instanceof ArithmeticTerm) { + return reifyArithmeticTerm(termId, (ArithmeticTerm) term); + } else if (term instanceof FunctionTerm) { + return reifyFunctionTerm(termId, (FunctionTerm) term); + } else { + throw new IllegalArgumentException("Cannot reify term of type " + term.getClass().getSimpleName()); + } + } + + Set reifyConstantTerm(ConstantTerm termId, ConstantTerm term) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); + reified.add(Atoms.newBasicAtom(CONSTANT_TERM_CLASS, termId, + Terms.newConstant(term.getObject().getClass().getName()))); + reified.add(Atoms.newBasicAtom(CONSTANT_TERM_SYMBOLIC, termId, + Terms.newSymbolicConstant(Boolean.toString(term.isSymbolic())))); + reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString()))); + return reified; + } + + Set reifyVariableTerm(ConstantTerm termId, VariableTerm term) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_VARIABLE)); + reified.add(Atoms.newBasicAtom(VARIABLE_TERM_SYMBOL, termId, Terms.newConstant(term.toString()))); + return reified; + } + + Set reifyArithmeticTerm(ConstantTerm termId, ArithmeticTerm term) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_ARITHMETIC)); + ConstantTerm leftTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_LEFT, termId, leftTermId)); + reified.addAll(reifyTerm(leftTermId, term.getLeftOperand())); + ConstantTerm rightTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_RIGHT, termId, rightTermId)); + reified.addAll(reifyTerm(rightTermId, term.getRightOperand())); + reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_OPERATOR, termId, Terms.newConstant(term.getOperator().toString()))); + return reified; + } + + Set reifyFunctionTerm(ConstantTerm termId, FunctionTerm term) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_FUNCTION)); + reified.add(Atoms.newBasicAtom(FUNCTION_TERM_SYMBOL, termId, Terms.newConstant(term.getSymbol()))); + for (int i = 0; i < term.getTerms().size(); i++) { + ConstantTerm argTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(FUNCTION_TERM_ARGUMENT, termId, Terms.newConstant(i), argTermId)); + reified.addAll(reifyTerm(argTermId, term.getTerms().get(i))); + } + return reified; } } From a34319cfd0655cd45fd196ccbb554f8611627572 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 11 Jan 2022 15:31:24 +0100 Subject: [PATCH 04/96] API method and CLI option for reification --- .../java/at/ac/tuwien/kr/alpha/api/Alpha.java | 10 ++++++ .../kr/alpha/api/config/InputConfig.java | 14 ++++++-- .../main/java/at/ac/tuwien/kr/alpha/Main.java | 32 +++++++++++++------ .../alpha/app/config/CommandLineParser.java | 11 +++++-- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 27 ++++++++++++---- 5 files changed, 73 insertions(+), 21 deletions(-) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java index d1b37b00c..71a9fbd29 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java @@ -4,6 +4,7 @@ import java.nio.file.Path; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.stream.Stream; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; @@ -11,6 +12,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; /** * Main API entry point for the Alpha ASP system. Provides facilities for parsing, normalizing and solving ASP programs. @@ -146,4 +148,12 @@ public interface Alpha { */ Solver prepareSolverFor(NormalProgram program, java.util.function.Predicate filter); + /** + * Reifies, i.e. re-expresses as a set of ASP facts, the given input program. + * + * @param program an ASP program to reify + * @return a set of {@link BasicAtom}s encoding the given program + */ + Set reify(ASPCore2Program program); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java index 5ce30a2bb..0586ed95c 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java @@ -26,6 +26,7 @@ public class InputConfig { public static final String DEFAULT_PREPROC_TARGET_FILE = "input.preproc.asp"; public static final boolean DEFAULT_WRITE_XLSX = false; public static final String DEFAULT_XLSX_OUTFILE_PATH = "alphaAnswerSet"; // current directory, files named "alphaAnswerSet.{num}.{ext}" + public static final boolean DEFAULT_REIFY_INPUT = false; private List aspStrings = new ArrayList<>(); private List files = new ArrayList<>(); @@ -37,11 +38,12 @@ public class InputConfig { private String compgraphPath = InputConfig.DEFAULT_COMPGRAPH_TARGET_FILE; private String normalizedPath = InputConfig.DEFAULT_NORMALIZED_TARGET_FILE; private String preprocessedPath = InputConfig.DEFAULT_PREPROC_TARGET_FILE; - - private Map predicateMethods = new HashMap<>(); private boolean writeAnswerSetsAsXlsx = InputConfig.DEFAULT_WRITE_XLSX; private String answerSetFileOutputPath; + private boolean reifyInput = InputConfig.DEFAULT_REIFY_INPUT; + private Map predicateMethods = new HashMap<>(); + public static InputConfig forString(String str) { InputConfig retVal = new InputConfig(); retVal.aspStrings.add(str); @@ -209,4 +211,12 @@ public void setDebugPreprocessing(boolean debugPreprocessing) { this.debugPreprocessing = debugPreprocessing; } + public boolean isReifyInput() { + return reifyInput; + } + + public void setReifyInput(boolean reifyInput) { + this.reifyInput = reifyInput; + } + } diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java index 487e25099..9e07d0219 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java @@ -33,6 +33,7 @@ import java.io.IOException; import java.io.PrintStream; import java.nio.file.Paths; +import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiConsumer; import java.util.stream.Collectors; @@ -55,6 +56,7 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.util.AnswerSetFormatter; import at.ac.tuwien.kr.alpha.app.ComponentGraphWriter; import at.ac.tuwien.kr.alpha.app.DependencyGraphWriter; @@ -92,18 +94,28 @@ public static void main(String[] args) { } InputConfig inputCfg = cfg.getInputConfig(); - Solver solver; - if (inputCfg.isDebugPreprocessing()) { - DebugSolvingContext dbgCtx = alpha.prepareDebugSolve(program); - Main.writeNormalProgram(dbgCtx.getNormalizedProgram(), inputCfg.getNormalizedPath()); - Main.writeNormalProgram(dbgCtx.getPreprocessedProgram(), inputCfg.getPreprocessedPath()); - Main.writeDependencyGraph(dbgCtx.getDependencyGraph(), inputCfg.getDepgraphPath()); - Main.writeComponentGraph(dbgCtx.getComponentGraph(), inputCfg.getCompgraphPath()); - solver = dbgCtx.getSolver(); + + // Note: We might potentially want to get the reified program as an AnswerSet and + // apply all the formatting we can do on answer sets also on reified programs. + if (inputCfg.isReifyInput()) { + Set reified = alpha.reify(program); + for (BasicAtom atom : reified) { + System.out.println(atom); + } } else { - solver = alpha.prepareSolverFor(program, inputCfg.getFilter()); + Solver solver; + if (inputCfg.isDebugPreprocessing()) { + DebugSolvingContext dbgCtx = alpha.prepareDebugSolve(program); + Main.writeNormalProgram(dbgCtx.getNormalizedProgram(), inputCfg.getNormalizedPath()); + Main.writeNormalProgram(dbgCtx.getPreprocessedProgram(), inputCfg.getPreprocessedPath()); + Main.writeDependencyGraph(dbgCtx.getDependencyGraph(), inputCfg.getDepgraphPath()); + Main.writeComponentGraph(dbgCtx.getComponentGraph(), inputCfg.getCompgraphPath()); + solver = dbgCtx.getSolver(); + } else { + solver = alpha.prepareSolverFor(program, inputCfg.getFilter()); + } + Main.computeAndConsumeAnswerSets(solver, cfg); } - Main.computeAndConsumeAnswerSets(solver, cfg); } /** diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java index 4b3ccf1f5..fcefe55fc 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java @@ -88,6 +88,7 @@ public class CommandLineParser { .desc("write files for normalized and preprocessed programs, also emit dependency- and component graphs as (graphviz) dot files").build(); private static final Option OPT_WRITE_XSLX = Option.builder("wx").longOpt("write-xlsx").hasArg(true).argName("path").type(String.class) .desc("Write answer sets to excel files, i.e. xlsx workbooks (one workbook per answer set)").build(); + private static final Option OPT_REIFY = Option.builder("reify").longOpt("reifyProgram").hasArg(false).desc("Reifies, i.e. encodes as ASP facts, the given program.").build(); // general system-wide config private static final Option OPT_GROUNDER = Option.builder("g").longOpt("grounder").hasArg(true).argName("grounder") @@ -166,6 +167,7 @@ public class CommandLineParser { CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_ASPSTRING); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_DEBUG_PREPROCESSING); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_WRITE_XSLX); + CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_REIFY); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_SOLVER); @@ -256,6 +258,7 @@ private void initializeInputOptionHandlers() { this.inputOptionHandlers.put(CommandLineParser.OPT_LITERATE.getOpt(), this::handleLiterate); this.inputOptionHandlers.put(CommandLineParser.OPT_DEBUG_PREPROCESSING.getOpt(), this::handleDebugPreprocessing); this.inputOptionHandlers.put(CommandLineParser.OPT_WRITE_XSLX.getOpt(), this::handleWriteXlsx); + this.inputOptionHandlers.put(CommandLineParser.OPT_REIFY.getOpt(), this::handleReify); } public AlphaConfig parseCommandLine(String[] args) throws ParseException { @@ -425,6 +428,10 @@ private void handleWriteXlsx(Option opt, InputConfig cfg) { cfg.setAnswerSetFileOutputPath(outputPath); } + private void handleReify(Option opt, InputConfig cfg) { + cfg.setReifyInput(true); + } + private void handleStats(Option opt, SystemConfig cfg) { cfg.setPrintStats(true); } @@ -436,7 +443,7 @@ private void handleNoJustification(Option opt, SystemConfig cfg) { private void handleDisableSortingGrid(Option opt, SystemConfig cfg) { cfg.getAggregateRewritingConfig().setUseSortingGridEncoding(false); } - + private void handleDisableNegativeSumElements(Option opt, SystemConfig cfg) { cfg.getAggregateRewritingConfig().setSupportNegativeValuesInSums(false); } @@ -470,5 +477,5 @@ private void handleGrounderNoInstanceRemoval(Option opt, SystemConfig cfg) { private void handleAtomSeparator(Option opt, SystemConfig cfg) { cfg.setAtomSeparator(StringEscapeUtils.unescapeJava(opt.getValue(SystemConfig.DEFAULT_ATOM_SEPARATOR))); } - + } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index c49a5ca39..4877aca6d 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -36,6 +36,7 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -59,6 +60,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.commons.programs.ReificationHelper; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; @@ -231,8 +236,8 @@ public DebugSolvingContext prepareDebugSolve(ASPCore2Program program) { @Override public DebugSolvingContext prepareDebugSolve(NormalProgram program) { return prepareDebugSolve(program, InputConfig.DEFAULT_FILTER); - } - + } + @Override public DebugSolvingContext prepareDebugSolve(final ASPCore2Program program, java.util.function.Predicate filter) { return prepareDebugSolve(normalizeProgram(program), filter); @@ -253,27 +258,27 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u compGraph = analyzed.getComponentGraph(); final Solver solver = prepareSolverFor(analyzed, filter); return new DebugSolvingContext() { - + @Override public Solver getSolver() { return solver; } - + @Override public NormalProgram getPreprocessedProgram() { return preprocessed; } - + @Override public NormalProgram getNormalizedProgram() { return program; } - + @Override public DependencyGraph getDependencyGraph() { return depGraph; } - + @Override public ComponentGraph getComponentGraph() { return compGraph; @@ -291,4 +296,12 @@ public Solver prepareSolverFor(NormalProgram program, java.util.function.Predica return prepareSolverFor(performProgramPreprocessing(program), filter); } + @Override + public Set reify(ASPCore2Program program) { + final IntIdGenerator intIdGen = new IntIdGenerator(0); + return new ReificationHelper(() -> { + return Terms.newConstant(intIdGen.getNextId()); + }).reifyProgram(program); + } + } From 0aa1d30c6b9595e8b569eb54393aa4c52d8b1f62 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 11 Jan 2022 16:04:37 +0100 Subject: [PATCH 05/96] refine reification --- .../src/main/java/at/ac/tuwien/kr/alpha/Main.java | 2 +- .../alpha/commons/programs/ReificationHelper.java | 13 ++++++++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java index 9e07d0219..46c992573 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java @@ -100,7 +100,7 @@ public static void main(String[] args) { if (inputCfg.isReifyInput()) { Set reified = alpha.reify(program); for (BasicAtom atom : reified) { - System.out.println(atom); + System.out.println(atom + "."); } } else { Solver solver; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 352629acb..e35f17469 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -39,6 +39,9 @@ public class ReificationHelper { static final Predicate RULE_HEAD = Predicates.getPredicate("rule_head", 2); static final Predicate RULE_BODY_LITERAL = Predicates.getPredicate("rule_bodyLiteral", 2); + // Predicates describing facts. + static final Predicate FACT = Predicates.getPredicate("fact", 1); + // Predicates describing heads. static final Predicate HEAD_TYPE = Predicates.getPredicate("head_type", 2); @@ -172,7 +175,15 @@ public Set reifyProgram(ASPCore2Program program) { for (Rule rule : program.getRules()) { reified.addAll(reifyRule(rule)); } - // TODO add reified predicate info + for(Atom fact : program.getFacts()) { + ConstantTerm factId = idProvider.get(); + reified.add(Atoms.newBasicAtom(FACT, factId)); + reified.addAll(reifyAtom(factId, fact)); + } + for (Map.Entry> entry : reifiedPredicates.entrySet()) { + reified.add(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), + Terms.newConstant(entry.getKey().getArity()))); + } return reified; } From d7b9761a13ce8e61b8098998f5108a60ed3378de Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 11 Jan 2022 16:25:44 +0100 Subject: [PATCH 06/96] fix checkstyle violations --- .../ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index e35f17469..8ea9b0569 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -175,7 +175,7 @@ public Set reifyProgram(ASPCore2Program program) { for (Rule rule : program.getRules()) { reified.addAll(reifyRule(rule)); } - for(Atom fact : program.getFacts()) { + for (Atom fact : program.getFacts()) { ConstantTerm factId = idProvider.get(); reified.add(Atoms.newBasicAtom(FACT, factId)); reified.addAll(reifyAtom(factId, fact)); From 3240f1e450e3a599d1e301b48539fdbe78e98f0c Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 11 Jan 2022 21:01:18 +0100 Subject: [PATCH 07/96] commons: unit tests for term reification --- .../programs/ReificationHelperTest.java | 144 ++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java new file mode 100644 index 000000000..50450cc6f --- /dev/null +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -0,0 +1,144 @@ +package at.ac.tuwien.kr.alpha.commons.programs; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Set; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +import org.junit.jupiter.api.Test; + +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; + +public class ReificationHelperTest { + + private Supplier> newIdGenerator() { + return new Supplier>() { + + IntIdGenerator idGen = new IntIdGenerator(0); + + @Override + public ConstantTerm get() { + return Terms.newConstant(idGen.getNextId()); + } + + }; + } + + @Test + public void reifySymbolicConstant() { + ConstantTerm constant = Terms.newSymbolicConstant("someConstant"); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.String")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("true")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someConstant")))); + } + + @Test + public void reifyStringConstant() { + ConstantTerm constant = Terms.newConstant("someString"); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.String")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("false")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someString")))); + } + + @Test + public void reifyIntegerConstant() { + ConstantTerm constant = Terms.newConstant(666); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.Integer")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("false")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant(Integer.toString(666))))); + } + + @Test + public void reifyVariable() { + VariableTerm var = Terms.newVariable("SOME_VAR"); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyVariableTerm(reifiedId, var); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("variable")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("variableTerm_symbol", 2), reifiedId, Terms.newConstant("SOME_VAR")))); + } + + @Test + public void reifyArithmeticTerm() { + Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyArithmeticTerm(reifiedId, (ArithmeticTerm) arithmeticTerm); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("arithmetic")))); + assertTrue(reified.contains( + Atoms.newBasicAtom(Predicates.getPredicate("arithmeticTerm_operator", 2), reifiedId, Terms.newConstant(ArithmeticOperator.PLUS.toString())))); + assertTrue(reified.stream() + .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("arithmeticTerm_leftTerm", 2))) + .findFirst() + .isPresent()); + assertTrue(reified.stream() + .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("arithmeticTerm_rightTerm", 2))) + .findFirst() + .isPresent()); + } + + @Test + public void reifyFunctionTerm() { + FunctionTerm funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyFunctionTerm(reifiedId, funcTerm); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("function")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_symbol", 2), reifiedId, Terms.newConstant("f")))); + assertEquals(1, reified.stream() + .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("functionTerm_argumentTerm", 3))) + .collect(Collectors.toList()).size()); + } + + @Test + public void reifyTerm() { + Term constTerm = Terms.newConstant("bla"); + Term varTerm = Terms.newVariable("VAR"); + Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); + Term funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); + + Supplier> idGen = newIdGenerator(); + ReificationHelper reificationHelper = new ReificationHelper(idGen); + + ConstantTerm constId = idGen.get(); + Set reifiedConst = reificationHelper.reifyTerm(constId, constTerm); + assertTrue(reifiedConst.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), constId, Terms.newSymbolicConstant("constant")))); + + ConstantTerm varId = idGen.get(); + Set reifiedVar = reificationHelper.reifyTerm(varId, varTerm); + assertTrue(reifiedVar.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), varId, Terms.newSymbolicConstant("variable")))); + + ConstantTerm calcId = idGen.get(); + Set reifiedCalc = reificationHelper.reifyTerm(calcId, arithmeticTerm); + assertTrue(reifiedCalc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), calcId, Terms.newSymbolicConstant("arithmetic")))); + + ConstantTerm funcId = idGen.get(); + Set reifiedFunc = reificationHelper.reifyTerm(funcId, funcTerm); + assertTrue(reifiedFunc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), funcId, Terms.newSymbolicConstant("function")))); + } + +} From 227fbb4ca75ecf3f5b31966523efae36c3671bfc Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 14 Jan 2022 18:52:33 +0100 Subject: [PATCH 08/96] unit tests for basic and comparison atom reification --- .../commons/programs/ReificationHelper.java | 2 + .../programs/ReificationHelperTest.java | 84 +++++++++++++++++++ 2 files changed, 86 insertions(+) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 8ea9b0569..29ba05556 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -171,6 +171,7 @@ public ReificationHelper(Supplier> idProvider) { } public Set reifyProgram(ASPCore2Program program) { + // TODO reify directives Set reified = new LinkedHashSet<>(); for (Rule rule : program.getRules()) { reified.addAll(reifyRule(rule)); @@ -384,6 +385,7 @@ Set reifyConstantTerm(ConstantTerm termId, ConstantTerm term) { Terms.newConstant(term.getObject().getClass().getName()))); reified.add(Atoms.newBasicAtom(CONSTANT_TERM_SYMBOLIC, termId, Terms.newSymbolicConstant(Boolean.toString(term.isSymbolic())))); + // TODO what if a string contains quotes? reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString()))); return reified; } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index 50450cc6f..bc941d08b 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -3,13 +3,18 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.ArrayList; +import java.util.List; import java.util.Set; import java.util.function.Supplier; import java.util.stream.Collectors; import org.junit.jupiter.api.Test; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; +import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; @@ -18,6 +23,7 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; @@ -141,4 +147,82 @@ public void reifyTerm() { assertTrue(reifiedFunc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), funcId, Terms.newSymbolicConstant("function")))); } + @Test + public void reifyBasicAtom() { + BasicAtom atom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyBasicAtom(reifiedId, atom); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("basic")))); + assertEquals(2, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("basicAtom_term", 3))) + .collect(Collectors.toList()) + .size()); + } + + @Test + public void reifyComparisonAtom() { + ComparisonAtom atom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyComparisonAtom(reifiedId, atom); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("comparison")))); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("comparisonAtom_leftTerm", 2))) + .collect(Collectors.toList()) + .size()); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("comparisonAtom_rightTerm", 2))) + .collect(Collectors.toList()) + .size()); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("comparisonAtom_operator", 2), reifiedId, Terms.newSymbolicConstant("le")))); + } + + @Test + public void reifyAggregateElement() { + List elementTerms = new ArrayList<>(); + elementTerms.add(Terms.newVariable("X")); + List elementLiterals = new ArrayList<>(); + elementLiterals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom", 1), Terms.newVariable("X")).toLiteral()); + AggregateElement element = Atoms.newAggregateElement(elementTerms, elementLiterals); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyAggregateElement(reifiedId, element); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateElement_term", 3))) + .collect(Collectors.toList()) + .size()); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateElement_literal", 2))) + .collect(Collectors.toList()) + .size()); + } + + // @Test + // public void reifyAggregateAtom() { + // List element1Terms = new ArrayList<>(); + // element1Terms.add(Terms.newVariable("X")); + // List element1Literals = new ArrayList<>(); + // element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); + // AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); + + // List element2Terms = new ArrayList<>(); + // element1Terms.add(Terms.newVariable("Y")); + // List element2Literals = new ArrayList<>(); + // element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); + // AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); + + // AggregateAtom atom = Atoms.newAggregateAtom(lowerBoundOperator, lowerBoundTerm, aggregatefunction, aggregateElements) + // } + } From b4cf45b3f95321eb9a34cfdfc50979e32218e918 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 26 Jan 2022 14:48:59 +0100 Subject: [PATCH 09/96] unit tests for aggregate and external atom reification --- .../commons/programs/ReificationHelper.java | 2 + .../programs/ReificationHelperTest.java | 87 +++++++++++++++---- 2 files changed, 73 insertions(+), 16 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 29ba05556..7974ac020 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -318,10 +318,12 @@ Set reifyExternalAtom(ConstantTerm atomId, ExternalAtom atom) { reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); for (int i = 0; i < atom.getInput().size(); i++) { ConstantTerm inTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_INPUT_TERM, atomId, Terms.newConstant(i), inTermId)); reified.addAll(reifyTerm(inTermId, atom.getInput().get(i))); } for (int i = 0; i < atom.getOutput().size(); i++) { ConstantTerm outTermId = idProvider.get(); + reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_OUTPUT_TERM, atomId, Terms.newConstant(i), outTermId)); reified.addAll(reifyTerm(outTermId, atom.getOutput().get(i))); } return reified; diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index bc941d08b..5022fbefb 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Set; import java.util.function.Supplier; @@ -11,9 +12,12 @@ import org.junit.jupiter.api.Test; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; @@ -208,21 +212,72 @@ public void reifyAggregateElement() { .size()); } - // @Test - // public void reifyAggregateAtom() { - // List element1Terms = new ArrayList<>(); - // element1Terms.add(Terms.newVariable("X")); - // List element1Literals = new ArrayList<>(); - // element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); - // AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); - - // List element2Terms = new ArrayList<>(); - // element1Terms.add(Terms.newVariable("Y")); - // List element2Literals = new ArrayList<>(); - // element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); - // AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); - - // AggregateAtom atom = Atoms.newAggregateAtom(lowerBoundOperator, lowerBoundTerm, aggregatefunction, aggregateElements) - // } + @Test + public void reifyAggregateAtom() { + List element1Terms = new ArrayList<>(); + element1Terms.add(Terms.newVariable("X")); + List element1Literals = new ArrayList<>(); + element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); + AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); + + List element2Terms = new ArrayList<>(); + element1Terms.add(Terms.newVariable("Y")); + List element2Literals = new ArrayList<>(); + element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); + AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); + + List elements = new ArrayList<>(); + elements.add(element1); + elements.add(element2); + AggregateAtom atom = Atoms.newAggregateAtom(ComparisonOperators.EQ, Terms.newVariable("X"), AggregateFunctionSymbol.COUNT, elements); + + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyAggregateAtom(reifiedId, atom); + + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("aggregate")))); + assertTrue(reified + .contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateAtom_aggregateFunction", 2), reifiedId, Terms.newSymbolicConstant("count")))); + assertEquals(2, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateAtom_aggregateElement", 2))) + .collect(Collectors.toList()) + .size()); + } + + @Test + public void reifyExternalAtom() { + List extInput = new ArrayList<>(); + List extOutput = new ArrayList<>(); + extInput.add(Terms.newVariable("I")); + extOutput.add(Terms.newVariable("O")); + ExternalAtom atom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); + + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyExternalAtom(reifiedId, atom); + + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("external")))); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_name", 2))) + .collect(Collectors.toList()) + .size()); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_inputTerm", 3))) + .collect(Collectors.toList()) + .size()); + assertEquals(1, + reified.stream() + .filter( + (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_outputTerm", 3))) + .collect(Collectors.toList()) + .size()); + + } } From 40a336a5e9783cdc856a713cc31ce56de0314b48 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 26 Jan 2022 16:24:08 +0100 Subject: [PATCH 10/96] additional test for atom reification --- .../programs/ReificationHelperTest.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index 5022fbefb..2cdb7f98b 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -15,6 +15,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; @@ -277,7 +278,52 @@ public void reifyExternalAtom() { (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_outputTerm", 3))) .collect(Collectors.toList()) .size()); + } + + @Test + public void reifyAtom() { + Atom basicAtom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); + + Atom cmpAtom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); + + List element1Terms = new ArrayList<>(); + element1Terms.add(Terms.newVariable("X")); + List element1Literals = new ArrayList<>(); + element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); + AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); + List element2Terms = new ArrayList<>(); + element1Terms.add(Terms.newVariable("Y")); + List element2Literals = new ArrayList<>(); + element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); + AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); + List elements = new ArrayList<>(); + elements.add(element1); + elements.add(element2); + Atom aggAtom = Atoms.newAggregateAtom(ComparisonOperators.EQ, Terms.newVariable("X"), AggregateFunctionSymbol.COUNT, elements); + List extInput = new ArrayList<>(); + List extOutput = new ArrayList<>(); + extInput.add(Terms.newVariable("I")); + extOutput.add(Terms.newVariable("O")); + ExternalAtom extAtom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); + + Supplier> idGen = newIdGenerator(); + + ConstantTerm reifiedBasicAtomId = idGen.get(); + Set reifiedBasicAtom = new ReificationHelper(idGen).reifyAtom(reifiedBasicAtomId, basicAtom); + assertTrue(reifiedBasicAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedBasicAtomId, Terms.newSymbolicConstant("basic")))); + + ConstantTerm reifiedCmpAtomId = idGen.get(); + Set reifiedCmpAtom = new ReificationHelper(idGen).reifyAtom(reifiedCmpAtomId, cmpAtom); + assertTrue(reifiedCmpAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedCmpAtomId, Terms.newSymbolicConstant("comparison")))); + + ConstantTerm reifiedAggAtomId = idGen.get(); + Set reifiedAggAtom = new ReificationHelper(idGen).reifyAtom(reifiedAggAtomId, aggAtom); + assertTrue(reifiedAggAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedAggAtomId, Terms.newSymbolicConstant("aggregate")))); + + ConstantTerm reifiedExtAtomId = idGen.get(); + Set reifiedExtAtom = new ReificationHelper(idGen).reifyAtom(reifiedExtAtomId, extAtom); + assertTrue(reifiedExtAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedExtAtomId, Terms.newSymbolicConstant("external")))); } } From f1779cbc1c8415b21141f18adfbf6be2a2c24841 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 26 Jan 2022 16:58:24 +0100 Subject: [PATCH 11/96] constant term types: string, integer, symbol, object --- .../commons/programs/ReificationHelper.java | 18 ++++++++++++------ .../programs/ReificationHelperTest.java | 9 +++------ 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 7974ac020..62e5d2dc4 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -95,8 +95,7 @@ public class ReificationHelper { static final Predicate TERM_TYPE = Predicates.getPredicate("term_type", 2); // Predicates describing constant terms. - static final Predicate CONSTANT_TERM_CLASS = Predicates.getPredicate("constantTerm_class", 2); - static final Predicate CONSTANT_TERM_SYMBOLIC = Predicates.getPredicate("constantTerm_symbolic", 2); + static final Predicate CONSTANT_TERM_TYPE = Predicates.getPredicate("constantTerm_type", 2); static final Predicate CONSTANT_TERM_VALUE = Predicates.getPredicate("constantTerm_value", 2); // Predicates describing variable terms. @@ -147,6 +146,7 @@ public class ReificationHelper { private static final Map> CMP_OPS = new HashMap<>(); private static final Map> AGG_FUNCS = new HashMap<>(); + private static final Map, String> TERM_TYPES = new HashMap<>(); static { CMP_OPS.put(ComparisonOperators.EQ, CMP_OP_EQ); @@ -160,6 +160,9 @@ public class ReificationHelper { AGG_FUNCS.put(AggregateFunctionSymbol.SUM, AGGREGATE_FUNCTION_SUM); AGG_FUNCS.put(AggregateFunctionSymbol.MIN, AGGREGATE_FUNCTION_MIN); AGG_FUNCS.put(AggregateFunctionSymbol.MAX, AGGREGATE_FUNCTION_MAX); + + TERM_TYPES.put(String.class, "string"); + TERM_TYPES.put(Integer.class, "integer"); } private final Supplier> idProvider; @@ -382,11 +385,14 @@ Set reifyTerm(ConstantTerm termId, Term term) { Set reifyConstantTerm(ConstantTerm termId, ConstantTerm term) { Set reified = new LinkedHashSet<>(); + String termType; + if (term.isSymbolic()) { + termType = "symbol"; + } else { + termType = TERM_TYPES.getOrDefault(term.getObject().getClass(), "object(" + term.getObject().getClass().getName() + ")"); + } reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); - reified.add(Atoms.newBasicAtom(CONSTANT_TERM_CLASS, termId, - Terms.newConstant(term.getObject().getClass().getName()))); - reified.add(Atoms.newBasicAtom(CONSTANT_TERM_SYMBOLIC, termId, - Terms.newSymbolicConstant(Boolean.toString(term.isSymbolic())))); + reified.add(Atoms.newBasicAtom(CONSTANT_TERM_TYPE, termId, Terms.newConstant(termType))); // TODO what if a string contains quotes? reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString()))); return reified; diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index 2cdb7f98b..18f4632c5 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -54,8 +54,7 @@ public void reifySymbolicConstant() { ConstantTerm reifiedId = idGen.get(); Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.String")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("true")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("symbol")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someConstant")))); } @@ -66,8 +65,7 @@ public void reifyStringConstant() { ConstantTerm reifiedId = idGen.get(); Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.String")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("false")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someString")))); } @@ -78,8 +76,7 @@ public void reifyIntegerConstant() { ConstantTerm reifiedId = idGen.get(); Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_class", 2), reifiedId, Terms.newConstant("java.lang.Integer")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_symbolic", 2), reifiedId, Terms.newSymbolicConstant("false")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("integer")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant(Integer.toString(666))))); } From 7c8b7460569c42b619e7aaf0319cb54c92130368 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 26 Jan 2022 17:32:49 +0100 Subject: [PATCH 12/96] correctly handle strings containing quotes --- .../kr/alpha/commons/programs/ReificationHelper.java | 3 +-- .../commons/programs/ReificationHelperTest.java | 12 ++++++++++++ 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 62e5d2dc4..19f921214 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -393,8 +393,7 @@ Set reifyConstantTerm(ConstantTerm termId, ConstantTerm term) { } reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); reified.add(Atoms.newBasicAtom(CONSTANT_TERM_TYPE, termId, Terms.newConstant(termType))); - // TODO what if a string contains quotes? - reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString()))); + reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString().replace("\"", "\\\"")))); return reified; } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index 18f4632c5..547c60fe2 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -69,6 +69,18 @@ public void reifyStringConstant() { assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someString")))); } + @Test + public void reifyStringWithQuotes() { + ConstantTerm constant = Terms.newConstant("someStringWith\"Quotes\""); + Supplier> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.get(); + Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someStringWith\\\"Quotes\\\"")))); + + } + @Test public void reifyIntegerConstant() { ConstantTerm constant = Terms.newConstant(666); From 1de895d5932226cfc8f3cdf9ec5ec26dcf9461ef Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 31 Jan 2022 16:20:40 +0100 Subject: [PATCH 13/96] add number of items for reified elements with list properties --- .../commons/programs/ReificationHelper.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 19f921214..1522c711f 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -37,6 +37,7 @@ public class ReificationHelper { // Predicates describing rules. static final Predicate RULE = Predicates.getPredicate("rule", 1); static final Predicate RULE_HEAD = Predicates.getPredicate("rule_head", 2); + static final Predicate RULE_NUM_BODY_LITERALS = Predicates.getPredicate("rule_numBodyLiterals", 2); static final Predicate RULE_BODY_LITERAL = Predicates.getPredicate("rule_bodyLiteral", 2); // Predicates describing facts. @@ -51,8 +52,10 @@ public class ReificationHelper { // Predicates describing choice heads. static final Predicate CHOICE_HEAD_LOWER_BOUND = Predicates.getPredicate("choiceHead_lowerBound", 2); static final Predicate CHOICE_HEAD_UPPER_BOUND = Predicates.getPredicate("choiceHead_upperBound", 2); + static final Predicate CHOICE_HEAD_NUM_ELEMENTS = Predicates.getPredicate("choiceHead_numElements", 2); static final Predicate CHOICE_HEAD_ELEMENT = Predicates.getPredicate("choiceHead_element", 2); static final Predicate CHOICE_ELEMENT_ATOM = Predicates.getPredicate("choiceElement_atom", 2); + static final Predicate CHOICE_ELEMENT_NUM_CONDITION_LITERALS = Predicates.getPredicate("choiceElement_numConditionLiterals", 2); static final Predicate CHOICE_ELEMENT_CONDITION_LITERAL = Predicates.getPredicate("choiceElement_conditionLiteral", 2); // Predicates describing literals. @@ -67,6 +70,7 @@ public class ReificationHelper { // Predicates describing basic atoms. static final Predicate BASIC_ATOM_PREDICATE = Predicates.getPredicate("basicAtom_predicate", 2); + static final Predicate BASIC_ATOM_NUM_TERMS = Predicates.getPredicate("basicAtom_numTerms", 2); static final Predicate BASIC_ATOM_TERM = Predicates.getPredicate("basicAtom_term", 3); // Predicates describing comparison atoms. @@ -76,7 +80,9 @@ public class ReificationHelper { // Predicates describing external atoms. static final Predicate EXTERNAL_ATOM_NAME = Predicates.getPredicate("externalAtom_name", 2); + static final Predicate EXTERNAL_ATOM_NUM_INPUT_TERMS = Predicates.getPredicate("externalAtom_numInputTerms", 2); static final Predicate EXTERNAL_ATOM_INPUT_TERM = Predicates.getPredicate("externalAtom_inputTerm", 3); + static final Predicate EXTERNAL_ATOM_NUM_OUTPUT_TERMS = Predicates.getPredicate("externalAtom_numOutputTerms", 2); static final Predicate EXTERNAL_ATOM_OUTPUT_TERM = Predicates.getPredicate("externalAtom_outputTerm", 3); // Predicates describing aggregate atoms. @@ -85,10 +91,13 @@ public class ReificationHelper { static final Predicate AGGREGATE_ATOM_RIGHT_TERM = Predicates.getPredicate("aggregateAtom_rightHandTerm", 2); static final Predicate AGGREGATE_ATOM_RIGHT_OPERATOR = Predicates.getPredicate("aggregateAtom_rightHandOperator", 2); static final Predicate AGGREGATE_ATOM_AGGREGATE_FUNCTION = Predicates.getPredicate("aggregateAtom_aggregateFunction", 2); + static final Predicate AGGREGATE_ATOM_NUM_AGGREGATE_ELEMENTS = Predicates.getPredicate("aggregateAtom_numAggregateElements", 2); static final Predicate AGGREGATE_ATOM_AGGREGATE_ELEMENT = Predicates.getPredicate("aggregateAtom_aggregateElement", 2); // Predicates describing aggregate elements. + static final Predicate AGGREGATE_ELEMENT_NUM_TERMS = Predicates.getPredicate("aggregateElement_numTerms", 2); static final Predicate AGGREGATE_ELEMENT_TERM = Predicates.getPredicate("aggregateElement_term", 3); + static final Predicate AGGREGATE_ELEMENT_NUM_LITERALS = Predicates.getPredicate("aggregateElement_numLiterals", 2); static final Predicate AGGREGATE_ELEMENT_LITERAL = Predicates.getPredicate("aggregateElement_literal", 2); // Predicates describing terms. @@ -108,6 +117,7 @@ public class ReificationHelper { // Predicates describing function terms. static final Predicate FUNCTION_TERM_SYMBOL = Predicates.getPredicate("functionTerm_symbol", 2); + static final Predicate FUNCTION_TERM_NUM_ARGUMENTS = Predicates.getPredicate("functionTerm_numArguments", 2); static final Predicate FUNCTION_TERM_ARGUMENT = Predicates.getPredicate("functionTerm_argumentTerm", 3); // Constants describing head types. @@ -196,6 +206,7 @@ Set reifyRule(Rule rule) { ConstantTerm ruleId = idProvider.get(); reified.add(Atoms.newBasicAtom(RULE, ruleId)); reified.addAll(reifyHead(ruleId, rule.getHead())); + reified.add(Atoms.newBasicAtom(RULE_NUM_BODY_LITERALS, ruleId, Terms.newConstant(rule.getBody().size()))); for (Literal lit : rule.getBody()) { ConstantTerm literalId = idProvider.get(); reified.add(Atoms.newBasicAtom(RULE_BODY_LITERAL, ruleId, literalId)); @@ -236,6 +247,7 @@ Set reifyChoiceHead(ConstantTerm headId, ChoiceHead head) { if (head.getUpperBound() != null) { reified.add(Atoms.newBasicAtom(CHOICE_HEAD_UPPER_BOUND, headId, head.getUpperBound())); } + reified.add(Atoms.newBasicAtom(CHOICE_HEAD_NUM_ELEMENTS, headId, Terms.newConstant(head.getChoiceElements().size()))); for (ChoiceElement element : head.getChoiceElements()) { reified.addAll(reifyChoiceElement(headId, element)); } @@ -249,6 +261,7 @@ Set reifyChoiceElement(ConstantTerm headId, ChoiceElement element) ConstantTerm atomId = idProvider.get(); reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_ATOM, elementId, atomId)); reified.addAll(reifyAtom(atomId, element.getChoiceAtom())); + reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_NUM_CONDITION_LITERALS, elementId, Terms.newConstant(element.getConditionLiterals().size()))); for (Literal lit : element.getConditionLiterals()) { ConstantTerm literalId = idProvider.get(); reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_CONDITION_LITERAL, elementId, literalId)); @@ -291,6 +304,7 @@ Set reifyBasicAtom(ConstantTerm atomId, BasicAtom atom) { reifiedPredicates.put(atom.getPredicate(), predicateId); } reified.add(Atoms.newBasicAtom(BASIC_ATOM_PREDICATE, atomId, predicateId)); + reified.add(Atoms.newBasicAtom(BASIC_ATOM_NUM_TERMS, atomId, Terms.newConstant(atom.getTerms().size()))); for (int i = 0; i < atom.getTerms().size(); i++) { ConstantTerm termId = idProvider.get(); reified.add(Atoms.newBasicAtom(BASIC_ATOM_TERM, atomId, Terms.newConstant(i), termId)); @@ -319,11 +333,13 @@ Set reifyExternalAtom(ConstantTerm atomId, ExternalAtom atom) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_EXTERNAL)); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); + reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_INPUT_TERMS, atomId, Terms.newConstant(atom.getInput().size()))); for (int i = 0; i < atom.getInput().size(); i++) { ConstantTerm inTermId = idProvider.get(); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_INPUT_TERM, atomId, Terms.newConstant(i), inTermId)); reified.addAll(reifyTerm(inTermId, atom.getInput().get(i))); } + reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_OUTPUT_TERMS, atomId, Terms.newConstant(atom.getOutput().size()))); for (int i = 0; i < atom.getOutput().size(); i++) { ConstantTerm outTermId = idProvider.get(); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_OUTPUT_TERM, atomId, Terms.newConstant(i), outTermId)); @@ -346,6 +362,7 @@ Set reifyAggregateAtom(ConstantTerm atomId, AggregateAtom atom) { ConstantTerm rightTermId = idProvider.get(); reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_TERM, atomId, rightTermId)); } + reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_NUM_AGGREGATE_ELEMENTS, atomId, Terms.newConstant(atom.getAggregateElements().size()))); for (AggregateElement element : atom.getAggregateElements()) { ConstantTerm elementId = idProvider.get(); reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_ELEMENT, atomId, elementId)); @@ -356,11 +373,13 @@ Set reifyAggregateAtom(ConstantTerm atomId, AggregateAtom atom) { Set reifyAggregateElement(ConstantTerm elementId, AggregateElement element) { Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_TERMS, elementId, Terms.newConstant(element.getElementTerms().size()))); for (int i = 0; i < element.getElementTerms().size(); i++) { ConstantTerm termId = idProvider.get(); reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_TERM, elementId, Terms.newConstant(i), termId)); reified.addAll(reifyTerm(termId, element.getElementTerms().get(i))); } + reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_LITERALS, elementId, Terms.newConstant(element.getElementLiterals().size()))); for (Literal lit : element.getElementLiterals()) { ConstantTerm literalId = idProvider.get(); reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_LITERAL, elementId, literalId)); @@ -421,6 +440,7 @@ Set reifyFunctionTerm(ConstantTerm termId, FunctionTerm term) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_FUNCTION)); reified.add(Atoms.newBasicAtom(FUNCTION_TERM_SYMBOL, termId, Terms.newConstant(term.getSymbol()))); + reified.add(Atoms.newBasicAtom(FUNCTION_TERM_NUM_ARGUMENTS, termId, Terms.newConstant(term.getTerms().size()))); for (int i = 0; i < term.getTerms().size(); i++) { ConstantTerm argTermId = idProvider.get(); reified.add(Atoms.newBasicAtom(FUNCTION_TERM_ARGUMENT, termId, Terms.newConstant(i), argTermId)); From 39793fa3849f2e957c78f53a7042d384f9241e86 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 31 Jan 2022 19:03:40 +0100 Subject: [PATCH 14/96] extend unit tests --- .../kr/alpha/commons/programs/ReificationHelperTest.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java index 547c60fe2..018c62e8b 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java @@ -129,6 +129,7 @@ public void reifyFunctionTerm() { Set reified = new ReificationHelper(idGen).reifyFunctionTerm(reifiedId, funcTerm); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("function")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_symbol", 2), reifiedId, Terms.newConstant("f")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_numArguments", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, reified.stream() .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("functionTerm_argumentTerm", 3))) .collect(Collectors.toList()).size()); @@ -168,6 +169,7 @@ public void reifyBasicAtom() { ConstantTerm reifiedId = idGen.get(); Set reified = new ReificationHelper(idGen).reifyBasicAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("basic")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("basicAtom_numTerms", 2), reifiedId, Terms.newConstant(2)))); assertEquals(2, reified.stream() .filter( @@ -208,12 +210,14 @@ public void reifyAggregateElement() { Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); Set reified = new ReificationHelper(idGen).reifyAggregateElement(reifiedId, element); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numTerms", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, reified.stream() .filter( (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateElement_term", 3))) .collect(Collectors.toList()) .size()); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numLiterals", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, reified.stream() .filter( @@ -248,6 +252,7 @@ public void reifyAggregateAtom() { assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("aggregate")))); assertTrue(reified .contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateAtom_aggregateFunction", 2), reifiedId, Terms.newSymbolicConstant("count")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateAtom_numAggregateElements", 2), reifiedId, Terms.newConstant(2)))); assertEquals(2, reified.stream() .filter( @@ -269,6 +274,8 @@ public void reifyExternalAtom() { Set reified = new ReificationHelper(idGen).reifyExternalAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("external")))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("externalAtom_numInputTerms", 2), reifiedId, Terms.newConstant(1)))); + assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("externalAtom_numOutputTerms", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, reified.stream() .filter( From e3c3892977e8b98d0b9967ca742a1fef1d24d3f6 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 31 Jan 2022 20:05:45 +0100 Subject: [PATCH 15/96] integration test for reification feature --- .../kr/alpha/api/impl/AlphaImplTest.java | 78 ++++++++++++------- 1 file changed, 50 insertions(+), 28 deletions(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 176862d40..88e9591cb 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -64,6 +64,7 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; @@ -81,9 +82,9 @@ import at.ac.tuwien.kr.alpha.core.rules.BasicRule; public class AlphaImplTest { - + private static final Logger LOGGER = LoggerFactory.getLogger(AspStandardLibrary.class); - + //@formatter:off private static final String STRINGSTUFF_ASP = "string(\"bla\")." @@ -113,7 +114,7 @@ public class AlphaImplTest { //@formatter:on private static int invocations; - + @at.ac.tuwien.kr.alpha.api.externals.Predicate public static boolean isOne(int term) { invocations++; @@ -157,13 +158,13 @@ public void addsFacts() { @Test public void withExternalTypeConflict() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaImpl(); - InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); - inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); - Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); - Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); - assertEquals(expected, actual); -}); + Alpha system = new AlphaImpl(); + InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); + inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); + Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); + Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); + assertEquals(expected, actual); + }); } @Test @@ -223,12 +224,12 @@ public void noInput() throws Exception { @Test public void smallGraphWithWrongType() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaImpl(); - InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); - cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); - ASPCore2Program prog = system.readProgram(cfg); + Alpha system = new AlphaImpl(); + InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); + cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); + ASPCore2Program prog = system.readProgram(cfg); - system.solve(prog).collect(Collectors.toSet()); + system.solve(prog).collect(Collectors.toSet()); }); } @@ -350,10 +351,10 @@ public void withExternalViaAnnotation() throws Exception { @Test public void errorDuplicateExternal() { assertThrows(IllegalArgumentException.class, () -> { - InputConfig cfg = InputConfig.forString("someString."); - cfg.addPredicateMethods(Externals.scan(this.getClass())); - cfg.addPredicateMethods(Externals.scan(this.getClass())); -}); + InputConfig cfg = InputConfig.forString("someString."); + cfg.addPredicateMethods(Externals.scan(this.getClass())); + cfg.addPredicateMethods(Externals.scan(this.getClass())); + }); } @Test @@ -421,7 +422,7 @@ public void withExternalInvocationCounted3() throws Exception { Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); assertEquals(expected, actual); } - + @Test @SuppressWarnings("unchecked") public void programWithExternalStringStuff() throws IOException { @@ -456,6 +457,27 @@ public void withNegatedExternal() throws IOException { } } + @Test + public void reifyInput() { + String aspInput = "p(X) :- q(X), not r(X)."; + Alpha system = new AlphaImpl(); + ASPCore2Program input = system.readProgramString(aspInput); + Set reified = system.reify(input); + + Set reifiedPredicates = reified.stream() + .filter((a) -> a.getPredicate().equals(Predicates.getPredicate("predicate", 3))) + .collect(Collectors.toSet()); + Set reifiedRuleHeads = reified.stream() + .filter((a) -> a.getPredicate().equals(Predicates.getPredicate("rule_head", 2))) + .collect(Collectors.toSet()); + Set reifiedBodyLiterals = reified.stream() + .filter((a) -> a.getPredicate().equals(Predicates.getPredicate("rule_bodyLiteral", 2))) + .collect(Collectors.toSet()); + assertEquals(3, reifiedPredicates.size()); + assertEquals(1, reifiedRuleHeads.size()); + assertEquals(2, reifiedBodyLiterals.size()); + } + @Test public void basicUsage() throws Exception { Alpha system = new AlphaImpl(); @@ -499,7 +521,7 @@ public void disableStratifiedEvalTest() { ASPCore2Program input = system.readProgramString(progstr); NormalProgram normal = system.normalizeProgram(input); CompiledProgram preprocessed = system.performProgramPreprocessing(normal); - assertFalse(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), + assertFalse(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), "Preprocessed program contains fact derived from stratifiable rule, but should not!"); } @@ -600,16 +622,17 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep ASPCore2Program prog = system.readProgram(inputCfg); assertFalse(system.solve(prog).limit(limit).collect(Collectors.toList()).isEmpty()); } - + // Detailed reproduction test-case for github issue #239. @Test public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { final ProgramParser parser = new ProgramParserImpl(); InputProgram.Builder bld = InputProgram.builder(); bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), StandardOpenOption.READ))); - bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); + bld.accumulate( + parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); InputProgram parsedProgram = bld.build(); - + SystemConfig config = new SystemConfig(); config.setSolverName("default"); config.setNogoodStoreName("alpharoaming"); @@ -619,12 +642,11 @@ public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOE config.setDisableJustificationSearch(false); config.setEvaluateStratifiedPart(false); config.setReplayChoices(Arrays.asList(21, 26, 36, 56, 91, 96, 285, 166, 101, 290, 106, 451, 445, 439, 448, - 433, 427, 442, 421, 415, 436, 409, 430, 397, 391, 424, 385, 379, - 418, 373, 412, 406, 394, 388, 382, 245, 232, 208 - )); + 433, 427, 442, 421, 415, 436, 409, 430, 397, 391, 424, 385, 379, + 418, 373, 412, 406, 394, 388, 382, 245, 232, 208)); Alpha alpha = new AlphaImpl(config); Optional answerSet = alpha.solve(parsedProgram).findFirst(); assertTrue(answerSet.isPresent()); } - + } From a990c8bc9eaa2d88fa6a8709029dc266f964f4c6 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 31 Jan 2022 22:37:57 +0100 Subject: [PATCH 16/96] fix NPE in constraint reification --- .../ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java index 1522c711f..240ec89a8 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java @@ -187,6 +187,9 @@ public Set reifyProgram(ASPCore2Program program) { // TODO reify directives Set reified = new LinkedHashSet<>(); for (Rule rule : program.getRules()) { + if (rule.isConstraint()) { + continue; + } reified.addAll(reifyRule(rule)); } for (Atom fact : program.getFacts()) { From fdc4902aa0cf4040da339c7581c85518017d4219 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 10 Feb 2022 11:48:25 +0100 Subject: [PATCH 17/96] add action heads and draft evaluation --- .../kr/alpha/api/config/SystemConfig.java | 10 ++++ .../kr/alpha/api/programs/actions/Action.java | 22 +++++++ .../programs/literals/ComparisonLiteral.java | 2 +- .../kr/alpha/api/rules/RuleInstantiator.java | 11 ++++ .../kr/alpha/api/rules/heads/ActionHead.java | 17 ++++++ .../api/rules/heads/InstantiableHead.java | 11 ++++ .../kr/alpha/api/rules/heads/NormalHead.java | 2 +- .../alpha/app/config/CommandLineParser.java | 4 -- .../commons/rules/heads/ActionHeadImpl.java | 59 +++++++++++++++++++ .../kr/alpha/commons/rules/heads/Heads.java | 8 ++- .../commons/rules/heads/NormalHeadImpl.java | 9 ++- .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 7 ++- .../tuwien/kr/alpha/core/actions/Actions.java | 21 +++++++ ...erImpl.java => AbstractProgramParser.java} | 20 ++++--- .../ASPCore2ParseTreeVisitor.java} | 27 ++++++--- .../aspcore2/ASPCore2ProgramParser.java | 23 ++++++++ .../ASPCore2ProgramPartParser.java} | 10 ++-- .../parser/evolog/EvologParseTreeVisitor.java | 43 ++++++++++++++ .../parser/evolog/EvologProgramParser.java | 23 ++++++++ .../kr/alpha/core/programs/Programs.java | 6 +- .../IntervalTermToIntervalAtom.java | 1 + .../transformation/PredicateInternalizer.java | 10 +++- .../transformation/StratifiedEvaluation.java | 58 +++++++++++++++++- .../VariableEqualityRemoval.java | 3 +- .../encoders/AggregateEncoderFactory.java | 4 +- .../aggregates/encoders/MinMaxEncoder.java | 6 +- .../tuwien/kr/alpha/core/rules/BasicRule.java | 3 +- .../kr/alpha/core/rules/InternalRule.java | 1 + .../alpha/core/solver/NaiveNoGoodStore.java | 2 + .../kr/alpha/core/util/Substitutions.java | 4 +- .../alpha/core/parser/AspCore2ParserTest.java | 11 ++++ .../alpha/core/parser/EvologParserTest.java | 13 ++++ .../kr/alpha/core/parser/ParserTest.java | 22 ++++--- .../ProgramTransformationTest.java | 5 +- .../kr/alpha/test/AnswerSetsParser.java | 4 +- .../kr/alpha/api/impl/AlphaFactory.java | 6 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 2 + .../alpha/AggregateRewritingContextTest.java | 4 +- .../alpha/ArithmeticTermsRewritingTest.java | 4 +- .../at/ac/tuwien/kr/alpha/RuleParser.java | 4 +- .../ac/tuwien/kr/alpha/RuleToStringTest.java | 4 +- .../kr/alpha/api/impl/AlphaImplTest.java | 4 +- .../alpha/regressiontests/HanoiTowerTest.java | 4 +- .../HeadBodyTransformationTests.java | 4 +- .../regressiontests/OmigaBenchmarksTest.java | 4 +- .../kr/alpha/regressiontests/RacksTest.java | 4 +- .../ThreeColouringRandomGraphTest.java | 4 +- .../ThreeColouringTestWithRandom.java | 4 +- .../ThreeColouringWheelTest.java | 4 +- 49 files changed, 453 insertions(+), 85 deletions(-) create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/RuleInstantiator.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/InstantiableHead.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{ProgramParserImpl.java => AbstractProgramParser.java} (91%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{ParseTreeVisitor.java => aspcore2/ASPCore2ParseTreeVisitor.java} (95%) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{ProgramPartParser.java => aspcore2/ASPCore2ProgramPartParser.java} (87%) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java create mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java create mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java index e5c94fefd..ec129fbc4 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java @@ -44,6 +44,7 @@ public class SystemConfig { // initializing from those values in order to have the values accessible in // contexts where no AlphaConfig instance exists (e.g. argument parsing from // command line) + public static final boolean DEFAULT_ACCEPT_EVOLOG = true; public static final String DEFAULT_SOLVER_NAME = "default"; public static final String DEFAULT_NOGOOD_STORE_NAME = "alphaRoaming"; public static final Heuristic DEFAULT_BRANCHING_HEURISTIC = Heuristic.VSIDS; @@ -63,6 +64,7 @@ public class SystemConfig { public static final String DEFAULT_ATOM_SEPARATOR = ", "; public static final AggregateRewritingConfig DEFAULT_AGGREGATE_REWRITING_CONFIG = new AggregateRewritingConfig(); + private boolean acceptEvologPrograms = DEFAULT_ACCEPT_EVOLOG; private String solverName = DEFAULT_SOLVER_NAME; private String nogoodStoreName = DEFAULT_NOGOOD_STORE_NAME; private long seed = DEFAULT_SEED; @@ -253,4 +255,12 @@ public void setAggregateRewritingConfig(AggregateRewritingConfig aggregateRewrit this.aggregateRewritingConfig = aggregateRewritingConfig; } + public boolean isAcceptEvologPrograms() { + return this.acceptEvologPrograms; + } + + public void setAcceptEvologPrograms(boolean acceptEvologPrograms) { + this.acceptEvologPrograms = acceptEvologPrograms; + } + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java new file mode 100644 index 000000000..4c4b350b9 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java @@ -0,0 +1,22 @@ +package at.ac.tuwien.kr.alpha.api.programs.actions; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +/** + * An action that gets executed as part of an action rule in an evolog program firing. + * + * Copyright (c) 2021, the Alpha Team. + */ +@FunctionalInterface +public interface Action { + + /** + * @param input a list of (ground) terms constituting the input of the action + * @return a function term representing the result of executing the action + */ + FunctionTerm execute(List input); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java index 01b7d6075..5abf83c95 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/ComparisonLiteral.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs.literals; -public interface ComparisonLiteral extends Literal, FixedInterpretationLiteral { +public interface ComparisonLiteral extends FixedInterpretationLiteral { boolean isLeftOrRightAssigning(); diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/RuleInstantiator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/RuleInstantiator.java new file mode 100644 index 000000000..2a521290c --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/RuleInstantiator.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.rules; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.heads.InstantiableHead; + +public interface RuleInstantiator { + + BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java new file mode 100644 index 000000000..1bc4c2674 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java @@ -0,0 +1,17 @@ +package at.ac.tuwien.kr.alpha.api.rules.heads; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; + +public interface ActionHead extends NormalHead { + + Action getAction(); + + List getActionInputTerms(); + + VariableTerm getActionOutputTerm(); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/InstantiableHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/InstantiableHead.java new file mode 100644 index 000000000..33c9c5f7f --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/InstantiableHead.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.rules.heads; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.RuleInstantiator; + +public interface InstantiableHead extends Head { + + BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java index 64c335807..4080c927d 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java @@ -7,7 +7,7 @@ * * Copyright (c) 2021, the Alpha Team. */ -public interface NormalHead extends Head { +public interface NormalHead extends InstantiableHead { BasicAtom getAtom(); diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java index b8a27f880..8b68d0dc1 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java @@ -349,10 +349,6 @@ private void handleSort(Option opt, SystemConfig cfg) { cfg.setSortAnswerSets(true); } - private void handleDeterministic(Option opt, SystemConfig cfg) { - cfg.setSeed(0); - } - private void handleSeed(Option opt, SystemConfig cfg) { String optVal = opt.getValue(); long seed; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java new file mode 100644 index 000000000..a7310a771 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java @@ -0,0 +1,59 @@ +package at.ac.tuwien.kr.alpha.commons.rules.heads; + +import java.util.Collections; +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.RuleInstantiator; +import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; + +class ActionHeadImpl implements ActionHead { + + private final BasicAtom atom; + private final Action action; + private final List actionInputTerms; + private final VariableTerm actionOutputTerm; + + ActionHeadImpl(BasicAtom atom, Action action, List actionInputTerms, VariableTerm actionOutputTerm) { + this.atom = atom; + this.action = action; + this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); + this.actionOutputTerm = actionOutputTerm; + } + + @Override + public BasicAtom getAtom() { + return atom; + } + + @Override + public boolean isGround() { + // TODO: an action head is conceptually a basic one with an (interpreted) function term + return false; + } + + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + + @Override + public Action getAction() { + return action; + } + + @Override + public List getActionInputTerms() { + return actionInputTerms; + } + + @Override + public VariableTerm getActionOutputTerm() { + return actionOutputTerm; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java index 9e529a7e7..860ca5ee7 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java @@ -3,12 +3,15 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; public final class Heads { @@ -29,5 +32,8 @@ public static ChoiceHead newChoiceHead(List choiceElements, Term public static ChoiceElement newChoiceElement(BasicAtom choiceAtom, List conditionLiterals) { return new ChoiceElementImpl(choiceAtom, conditionLiterals); } - + + public static ActionHead newActionHead(BasicAtom atom, Action action, List actionInputTerms, VariableTerm actionResult) { + return new ActionHeadImpl(atom, action, actionInputTerms, actionResult); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java index 2cdfc4404..b06ae99b6 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java @@ -1,11 +1,13 @@ package at.ac.tuwien.kr.alpha.commons.rules.heads; +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.RuleInstantiator; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; /** * Represents a normal head, i.e., a head that is an Atom. - * Copyright (c) 2019, the Alpha Team. + * Copyright (c) 2019-2021, the Alpha Team. */ class NormalHeadImpl implements NormalHead { @@ -61,4 +63,9 @@ public boolean equals(Object obj) { return true; } + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + } diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index aeca5cc2d..a8dada32d 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -6,6 +6,7 @@ import ASPLexer; * https://www.mat.unical.it/aspcomp2013/files/ASP-CORE-2.01c.pdf * (sections 4 and 5, pages 10-12). * It is extended a bit to parse widespread syntax (e.g. used by gringo/clasp). + * Furthermore, syntax features specific to Alpha's Evolog extension (action rules, asp modules) are included. */ program : statements? query? EOF; @@ -20,7 +21,9 @@ statement : head DOT # statement_fact | WCONS body? DOT SQUARE_OPEN weight_at_level SQUARE_CLOSE # statement_weightConstraint | directive # statement_directive; // NOT Core2 syntax. -head : disjunction | choice; +head : disjunction | choice | action; + +action: classical_literal COLON AT ID SQUARE_OPEN terms SQUARE_CLOSE EQUAL variable_term; // NOT Core2 syntax body : ( naf_literal | aggregate ) (COMMA body)?; @@ -87,4 +90,4 @@ variable_term : VARIABLE | ANONYMOUS_VARIABLE; answer_set : CURLY_OPEN classical_literal? (COMMA classical_literal)* CURLY_CLOSE; -answer_sets: answer_set* EOF; \ No newline at end of file +answer_sets: answer_set* EOF; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java new file mode 100644 index 000000000..5aff462d6 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -0,0 +1,21 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; + +public class Actions { + + public static FunctionTerm printLine(List input) { + if (input.size() != 1) { + // TODO do properly + throw new RuntimeException("Incorrect arity!"); + } + // TODO this should only work on ConstantTerm + System.out.println(input.get(0).toString()); + return Terms.newFunctionTerm("ok"); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java similarity index 91% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java index e67cfaa4a..17684b602 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java @@ -22,18 +22,17 @@ import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ParseTreeVisitor; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -public class ProgramParserImpl implements ProgramParser { +public abstract class AbstractProgramParser implements ProgramParser { - private final Map preloadedExternals = new HashMap<>(); - - public ProgramParserImpl() { - this.preloadedExternals.putAll(Externals.getStandardLibraryExternals()); + private final Map preloadedExternals = new HashMap<>(Externals.getStandardLibraryExternals()); + + public AbstractProgramParser() { } - - public ProgramParserImpl(Map externals) { - this(); + + public AbstractProgramParser(Map externals) { this.preloadedExternals.putAll(externals); } @@ -126,7 +125,7 @@ public InputProgram parse(CharStream stream, Map programSources, Map externals); + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java similarity index 95% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java index 3042a1183..d817b57d2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.parser; +package at.ac.tuwien.kr.alpha.core.parser.aspcore2; import static java.util.Collections.emptyList; @@ -75,24 +75,25 @@ import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; +import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** - * Copyright (c) 2016-2018, the Alpha Team. + * Copyright (c) 2016-2021, the Alpha Team. */ -public class ParseTreeVisitor extends ASPCore2BaseVisitor { +public class ASPCore2ParseTreeVisitor extends ASPCore2BaseVisitor { private final Map externals; private final boolean acceptVariables; private InputProgramImpl.Builder programBuilder; private InlineDirectives inlineDirectives; - public ParseTreeVisitor(Map externals) { + public ASPCore2ParseTreeVisitor(Map externals) { this(externals, true); } - public ParseTreeVisitor(Map externals, boolean acceptVariables) { + public ASPCore2ParseTreeVisitor(Map externals, boolean acceptVariables) { this.externals = externals; this.acceptVariables = acceptVariables; } @@ -231,11 +232,21 @@ public Head visitDisjunction(ASPCore2Parser.DisjunctionContext ctx) { @Override public Head visitHead(ASPCore2Parser.HeadContext ctx) { - // head : disjunction | choice; + // head : disjunction | choice | action; if (ctx.choice() != null) { return visitChoice(ctx.choice()); + } else if (ctx.action() != null) { + return visitAction(ctx.action()); + } else if (ctx.disjunction() != null) { + return visitDisjunction(ctx.disjunction()); } - return visitDisjunction(ctx.disjunction()); + throw notSupported(ctx); + } + + @Override + public Head visitAction(ASPCore2Parser.ActionContext ctx) { + // Actions are an Evolog-specific feature and therefore not supported by the ASPCore2 parser. + throw notSupported(ctx); } @Override @@ -400,7 +411,7 @@ public Term visitGround_term(ASPCore2Parser.Ground_termContext ctx) { } @Override - public Term visitVariable_term(ASPCore2Parser.Variable_termContext ctx) { + public VariableTerm visitVariable_term(ASPCore2Parser.Variable_termContext ctx) { // variable_term : VARIABLE | ANONYMOUS_VARIABLE; if (ctx.VARIABLE() != null) { return Terms.newVariable(ctx.VARIABLE().getText()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java new file mode 100644 index 000000000..c4cd13ea7 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java @@ -0,0 +1,23 @@ +package at.ac.tuwien.kr.alpha.core.parser.aspcore2; + +import java.util.Map; + +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; + +public class ASPCore2ProgramParser extends AbstractProgramParser { + + public ASPCore2ProgramParser() { + super(); + } + + public ASPCore2ProgramParser(Map externals) { + super(externals); + } + + @Override + protected ASPCore2ParseTreeVisitor createParseTreeVisitor(Map externals) { + return new ASPCore2ParseTreeVisitor(externals); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java similarity index 87% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java index bc2690666..75ae21fd9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java @@ -26,7 +26,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.parser; +package at.ac.tuwien.kr.alpha.core.parser.aspcore2; import java.util.Collections; @@ -41,13 +41,15 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; +import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; /** - * A parser that, in contrast to {@link ProgramParserImpl}, does not parse full programs but only program parts like + * A parser that, in contrast to {@link AbstractProgramParser}, does not parse full programs but only program parts like * atoms, terms and such. */ -public class ProgramPartParser { - private final ParseTreeVisitor visitor = new ParseTreeVisitor(Collections.emptyMap(), true); +// TODO adapt this and create evolog version +public class ASPCore2ProgramPartParser { + private final ASPCore2ParseTreeVisitor visitor = new ASPCore2ParseTreeVisitor(Collections.emptyMap(), true); public Term parseTerm(String s) { final ASPCore2Parser parser = getASPCore2Parser(s); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java new file mode 100644 index 000000000..bf10553cc --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java @@ -0,0 +1,43 @@ +package at.ac.tuwien.kr.alpha.core.parser.evolog; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.core.actions.Actions; +import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ParseTreeVisitor; + +public class EvologParseTreeVisitor extends ASPCore2ParseTreeVisitor { + + private final Map actionRegistry = new HashMap<>(); + + public EvologParseTreeVisitor(Map externals, boolean acceptVariables) { + super(externals, acceptVariables); + actionRegistry.put("printLine", Actions::printLine); + } + + public EvologParseTreeVisitor(Map externals) { + this(externals, true); + } + + @Override + public Head visitAction(ASPCore2Parser.ActionContext ctx) { + BasicAtom atom = visitClassical_literal(ctx.classical_literal()); + VariableTerm actionResultTerm = visitVariable_term(ctx.variable_term()); + String actionId = ctx.ID().getText(); + if (!actionRegistry.containsKey(actionId)) { + throw new UnsupportedOperationException("Could not resolve action name " + actionId); + } + List actionInputTerms = visitTerms(ctx.terms()); + return Heads.newActionHead(atom, actionRegistry.get(actionId), actionInputTerms, actionResultTerm); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java new file mode 100644 index 000000000..9f1079922 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java @@ -0,0 +1,23 @@ +package at.ac.tuwien.kr.alpha.core.parser.evolog; + +import java.util.Map; + +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; + +public class EvologProgramParser extends AbstractProgramParser { + + public EvologProgramParser(Map externals) { + super(externals); + } + + public EvologProgramParser() { + super(); + } + + @Override + protected EvologParseTreeVisitor createParseTreeVisitor(Map externals) { + return new EvologParseTreeVisitor(externals); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java index e3f184886..83e9ab9c9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java @@ -8,7 +8,8 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; public class Programs { @@ -16,8 +17,9 @@ private Programs() { throw new AssertionError("This is a pure utility class and should therefore not be instantiated!"); } + // TODO integrate this Method into Alpha interface so we have a parser following overall system config public static InputProgram fromInputStream(InputStream is, Map externals) throws IOException { - ProgramParserImpl parser = new ProgramParserImpl(); + AbstractProgramParser parser = new EvologProgramParser(); return parser.parse(CharStreams.fromStream(is), externals); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 36920ec71..fd523432b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -78,6 +78,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { } // Note that this cast is safe: NormalHead can only have a BasicAtom, so literalizing and getting back the Atom destroys type information, // but should never yield anything other than a BasicAtom + // TODO what about intervals in action heads? NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead((BasicAtom) rewriteLiteral(rule.getHead().getAtom().toLiteral(), intervalReplacements).getAtom()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 9deb24b06..7662edff1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -10,6 +10,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; @@ -50,7 +51,14 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String } NormalHead head = (NormalHead) rule.getHead(); if (head.getAtom().getPredicate().getName().startsWith(prefix)) { - newHead = Heads.newNormalHead(makePredicateInternal(head.getAtom())); + // TODO do this nicely (using visitor?) + if (head instanceof ActionHead) { + ActionHead actionHead = (ActionHead) head; + newHead = Heads.newActionHead(makePredicateInternal(actionHead.getAtom()), actionHead.getAction(), actionHead.getActionInputTerms(), + actionHead.getActionOutputTerm()); + } else { + newHead = Heads.newNormalHead(makePredicateInternal(head.getAtom())); + } } else { newHead = head; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 2c3105134..379c86875 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -18,10 +18,19 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.RuleInstantiator; +import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; +import at.ac.tuwien.kr.alpha.api.rules.heads.InstantiableHead; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; @@ -43,7 +52,7 @@ * * Copyright (c) 2019-2020, the Alpha Team. */ -public class StratifiedEvaluation extends ProgramTransformation { +public class StratifiedEvaluation extends ProgramTransformation implements RuleInstantiator { private static final Logger LOGGER = LoggerFactory.getLogger(StratifiedEvaluation.class); @@ -301,7 +310,13 @@ private List calcSubstitutionsWithGroundingOrder(RuleGroundingOrde } private void fireRule(CompiledRule rule, Substitution substitution) { - Atom newAtom = rule.getHeadAtom().substitute(substitution); + // BasicAtom newAtom = this.instantiate(rule.getHead(), substitution); + BasicAtom newAtom; + if (rule.getHead() instanceof ActionHead) { + newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution); + } else { + newAtom = instantiateNormalHead(rule.getHead(), substitution); + } if (!newAtom.isGround()) { throw new IllegalStateException("Trying to fire rule " + rule.toString() + " with incompatible substitution " + substitution.toString()); } @@ -309,6 +324,45 @@ private void fireRule(CompiledRule rule, Substitution substitution) { workingMemory.addInstance(newAtom, true); } + @Override + public BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution) { + return ruleHead.instantiate(this, substitution); + } + + // FIXME should be dispatched via visitor pattern + public BasicAtom instantiateNormalHead(NormalHead head, Substitution substitution) { + return head.getAtom().substitute(substitution); + } + + // FIXME should be dispatched via visitor pattern + public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution) { + // TODO ensure unique action only gets executed once! + List actionInput = head.getActionInputTerms(); + List substitutedInput = new ArrayList<>(); + // Substitute all variables in action input so that all input terms are ground. + for (Term inputTerm : actionInput) { + // TODO handle variables nested in function terms as well! + if (inputTerm instanceof VariableTerm) { + VariableTerm inputVar = (VariableTerm) inputTerm; + if (!substitution.isVariableSet(inputVar)) { + throw new IllegalStateException( + "No substitute for action input variable " + inputVar.toString() + " in substitution: " + substitution.toString()); + } + substitutedInput.add(inputVar.substitute(substitution)); + } else { + substitutedInput.add(inputTerm); + } + } + // Call the actual action. + // TODO exception handling (translate EVERY throwable to an error term) + Action action = head.getAction(); + FunctionTerm actionResult = action.execute(substitutedInput); + // We have an action result. Add it to the substitution as the substitute for the variable bound to the action so we're able to obtain the + // ground BasicAtom derived by the rule + substitution.put(head.getActionOutputTerm(), actionResult); + return head.getAtom().substitute(substitution); + } + private ComponentEvaluationInfo getRulesToEvaluate(ComponentGraph.SCComponent comp) { Set nonRecursiveRules = new HashSet<>(); Set recursiveRules = new HashSet<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 11f361cd4..3d74801a1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -116,7 +116,8 @@ private Rule findAndReplaceVariableEquality(Rule rule) { if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } - NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead)rule.getHead()).getAtom()); + // TODO handle action heads! + NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); // Use substitution for actual replacement. Unifier replacementSubstitution = new Unifier(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java index cb3d1152a..c1a6ad17e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java @@ -34,11 +34,11 @@ public SumEncoder newSumLessOrEqualEncoder() { } public MinMaxEncoder newMinEncoder() { - return new MinMaxEncoder(AggregateFunctionSymbol.MIN); + return new MinMaxEncoder(parserFactory.get(), AggregateFunctionSymbol.MIN); } public MinMaxEncoder newMaxEncoder() { - return new MinMaxEncoder(AggregateFunctionSymbol.MAX); + return new MinMaxEncoder(parserFactory.get(), AggregateFunctionSymbol.MAX); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 316d1ad5c..9ecb6f0b2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -26,7 +26,6 @@ import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; import at.ac.tuwien.kr.alpha.core.rules.BasicRule; @@ -59,13 +58,14 @@ public class MinMaxEncoder extends AbstractAggregateEncoder { ); //@formatter:on - private final ProgramParser parser = new ProgramParserImpl(); + private final ProgramParser parser; - public MinMaxEncoder(AggregateFunctionSymbol func) { + public MinMaxEncoder(ProgramParser parser, AggregateFunctionSymbol func) { super(func, SetUtils.hashSet(ComparisonOperators.operators())); if (!(func == AggregateFunctionSymbol.MAX || func == AggregateFunctionSymbol.MIN)) { throw new IllegalArgumentException("Encoder " + this.getClass().getSimpleName() + " can only encode min/max aggregates!"); } + this.parser = parser; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java index 1c218769a..bc3076f85 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java @@ -31,7 +31,6 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; /** @@ -40,7 +39,7 @@ * This implementation represents a rule after being parsed from a given ASP program, but before being transformed into a * {@link NormalRuleImpl}. */ -public class BasicRule extends AbstractRule implements Rule { +public class BasicRule extends AbstractRule { public BasicRule(Head head, List body) { super(head, body); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java index 3283ac64f..0df14b399 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java @@ -110,6 +110,7 @@ public static CompiledRule fromNormalRule(Rule rule) { */ @Override public InternalRule renameVariables(String newVariablePostfix) { + // TODO handle action heads! List occurringVariables = new ArrayList<>(); BasicAtom headAtom = this.getHeadAtom(); occurringVariables.addAll(headAtom.getOccurringVariables()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java index 7eb8bc6a2..7a7222e5f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java @@ -38,6 +38,8 @@ import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.*; public class NaiveNoGoodStore implements NoGoodStore { + + @SuppressWarnings("unused") private static final Logger LOGGER = LoggerFactory.getLogger(NaiveNoGoodStore.class); private HashMap delegate = new HashMap<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java index 40470cf09..8d92163b0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java @@ -5,11 +5,11 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramPartParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramPartParser; public final class Substitutions { - private static final ProgramPartParser PROGRAM_PART_PARSER = new ProgramPartParser(); + private static final ASPCore2ProgramPartParser PROGRAM_PART_PARSER = new ASPCore2ProgramPartParser(); private Substitutions() { throw new AssertionError("Cannot instantiate utility class!"); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java new file mode 100644 index 000000000..fd40c3db6 --- /dev/null +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.core.parser; + +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; + +public class AspCore2ParserTest extends ParserTest { + + protected AspCore2ParserTest() { + super(new ASPCore2ProgramParser()); + } + +} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java new file mode 100644 index 000000000..5621615cc --- /dev/null +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java @@ -0,0 +1,13 @@ +package at.ac.tuwien.kr.alpha.core.parser; + +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; + +public class EvologParserTest extends ParserTest { + + protected EvologParserTest() { + super(new EvologProgramParser()); + } + + + +} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index f8346e33a..28e1f2574 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -33,6 +33,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; +import java.nio.channels.Channels; import java.nio.channels.ReadableByteChannel; import java.util.Arrays; import java.util.Collections; @@ -40,12 +41,11 @@ import java.util.Optional; import java.util.stream.Stream; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; @@ -62,10 +62,15 @@ import at.ac.tuwien.kr.alpha.commons.util.Util; /** - * Copyright (c) 2016, the Alpha Team. + * Copyright (c) 2016-2021, the Alpha Team. */ -public class ParserTest { - private final ProgramParserImpl parser = new ProgramParserImpl(); +public abstract class ParserTest { + + private final ProgramParser parser; + + protected ParserTest(ProgramParser parser) { + this.parser = parser; + } @Test public void parseFact() { @@ -167,7 +172,7 @@ public void literate() throws IOException { "", "Test!"))); - final String actual = new ProgramParserImpl().parse(CharStreams.fromChannel(input)).toString(); + final String actual = parser.parse(Channels.newInputStream(input)).toString(); final String expected = "p(a)." + System.lineSeparator(); assertEquals(expected, actual); @@ -221,8 +226,7 @@ public void cardinalityAggregate() { @Test public void stringWithEscapedQuotes() throws IOException { - CharStream stream = CharStreams.fromStream(ParserTest.class.getResourceAsStream("/escaped_quotes.asp")); - InputProgram prog = parser.parse(stream); + InputProgram prog = parser.parse(ParserTest.class.getResourceAsStream("/escaped_quotes.asp")); assertEquals(1, prog.getFacts().size()); Atom stringAtom = prog.getFacts().get(0); String stringWithQuotes = stringAtom.getTerms().get(0).toString(); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index d008dd21b..f56f48ccf 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -16,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; // TODO This is a functional test and should not be run with standard unit tests @@ -26,7 +26,8 @@ public class ProgramTransformationTest { private static final String TESTFILES_PATH = "/transform-test/"; - private static final ProgramParser PARSER = new ProgramParserImpl(); + // TODO should this always be an evolog parser? + private static final ProgramParser PARSER = new EvologProgramParser(); private ChoiceHeadToNormal choiceToNormal = new ChoiceHeadToNormal(); private IntervalTermToIntervalAtom intervalRewriting = new IntervalTermToIntervalAtom(); diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java index c98e29f3a..ecbac5312 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java @@ -14,11 +14,11 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; -import at.ac.tuwien.kr.alpha.core.parser.ParseTreeVisitor; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ParseTreeVisitor; public class AnswerSetsParser { - private static final ParseTreeVisitor VISITOR = new ParseTreeVisitor(Collections.emptyMap(), false); + private static final ASPCore2ParseTreeVisitor VISITOR = new ASPCore2ParseTreeVisitor(Collections.emptyMap(), false); public static Set parse(String s) { try { diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 9a3093255..b0e89d72e 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -9,7 +9,8 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; @@ -25,7 +26,8 @@ private AlphaFactory() { } public static Alpha newAlpha(SystemConfig cfg) { - Supplier parserFactory = () -> new ProgramParserImpl(); + // Parser factory - Supply correct parser dependent on the accepted input language. + Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); // AggregateEncoderFactory depends on parser factory since stringtemplate-based aggregate encoders need to use the same parser that's used // for input programs. diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 934ce13bd..f2106fb5e 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -156,6 +156,8 @@ InternalProgram performProgramPreprocessing(NormalProgram program) { InternalProgram retVal = InternalProgram.fromNormalProgram(program); if (enableStratifiedEvaluation) { AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); + // TODO as Evolog moves further along, we want to integrate stratified evaluation with grounder and solver. + // Therefore, leave it as is and don't make part of factory API for now. retVal = new StratifiedEvaluation().apply(analyzed); } return retVal; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java index bd7011667..0acbb173a 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java @@ -18,7 +18,7 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -60,7 +60,7 @@ public class AggregateRewritingContextTest { //@formatter:on private static final AggregateRewritingContext rewritingContextForAspString(String asp) { - InputProgram program = new ProgramParserImpl().parse(asp); + InputProgram program = new EvologProgramParser().parse(asp); AggregateRewritingContext ctx = new AggregateRewritingContext(); for (Rule rule : program.getRules()) { ctx.registerRule(rule); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index c812bfe95..d642e2cf8 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -23,7 +23,7 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; @@ -34,7 +34,7 @@ public class ArithmeticTermsRewritingTest { private final Map externalsOfThisClass = Externals.scan(ArithmeticTermsRewritingTest.class); - private final ProgramParser parser = new ProgramParserImpl(externalsOfThisClass); // Create parser that knows an implementation of external atom &extArithTest[](). + private final ProgramParser parser = new EvologProgramParser(externalsOfThisClass); // Create parser that knows an implementation of external atom &extArithTest[](). @Predicate(name = "extArithTest") public static Set>> externalForArithmeticTermsRewriting(Integer in) { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java index 4893a20d8..69982ad45 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java @@ -4,12 +4,12 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; public class RuleParser { public static Rule parse(String str) { - ProgramParser parser = new ProgramParserImpl(); + ProgramParser parser = new EvologProgramParser(); InputProgram prog = parser.parse(str); if (!prog.getFacts().isEmpty()) { throw new IllegalArgumentException("Expected exactly one rule and no facts!"); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index 46f359403..1234baadc 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -35,7 +35,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; @@ -45,7 +45,7 @@ * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. */ public class RuleToStringTest { - private final ProgramParser parser = new ProgramParserImpl(); + private final ProgramParser parser = new EvologProgramParser(); @Test public void positiveRuleToString() { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 96907fad6..4b3920483 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -75,7 +75,7 @@ import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.rules.BasicRule; @@ -620,7 +620,7 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep // Detailed reproduction test-case for github issue #239. @Test public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { - final ProgramParser parser = new ProgramParserImpl(); + final ProgramParser parser = new ASPCore2ProgramParser(); InputProgramImpl.Builder bld = InputProgramImpl.builder(); bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), StandardOpenOption.READ))); bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java index bb6231461..2110e98f4 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java @@ -50,7 +50,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -108,7 +108,7 @@ private void testHanoiTower(int instance, SystemConfig cfg) throws IOException { private void testHanoiTower(String instance, SystemConfig cfg) throws IOException { // TODO should be read by the Alpha instance constructed in buildSolverForRegressionTest, // do not instantiate parsers "free-style"! - InputProgram prog = new ProgramParserImpl().parse( + InputProgram prog = new ASPCore2ProgramParser().parse( Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), Paths.get("src", "test", "resources", "HanoiTower_instances", instance + ".asp")); Solver solver = buildSolverForRegressionTest(prog, cfg); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java index 63b6ff59b..36f0f1ecc 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java @@ -42,7 +42,7 @@ import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** * Tests rule transformations described in the following research paper, and their effects on performance: @@ -246,7 +246,7 @@ private InputProgram constructProgramA_TransformationA(int n) { private InputProgram checkNumberOfRulesAndParse(List strRules, int numberOfRules) { assertEquals(numberOfRules, strRules.size()); String strProgram = strRules.stream().collect(Collectors.joining(System.lineSeparator())); - InputProgram parsedProgram = new ProgramParserImpl().parse(strProgram); + InputProgram parsedProgram = new EvologProgramParser().parse(strProgram); assertEquals(numberOfRules, parsedProgram.getRules().size()); return parsedProgram; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java index 31c67bae2..c481b4a99 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java @@ -41,7 +41,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -112,7 +112,7 @@ public void testReach_4(SystemConfig cfg) { private void test(String folder, String aspFileName, SystemConfig cfg) throws IOException { @SuppressWarnings("unused") Optional answerSet = buildSolverForRegressionTest( - new ProgramParserImpl().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) + new EvologProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) .stream().findFirst(); // System.out.println(answerSet); // TODO: check correctness of answer set diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java index 6bca18e5e..ecdb85095 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java @@ -39,7 +39,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -61,7 +61,7 @@ public void testRacks(SystemConfig cfg) { private void test(SystemConfig cfg) throws IOException { CharStream programInputStream = CharStreams.fromPath( Paths.get("benchmarks", "siemens", "racks", "racks.lp")); - Solver solver = buildSolverForRegressionTest(new ProgramParserImpl().parse(programInputStream), cfg); + Solver solver = buildSolverForRegressionTest(new EvologProgramParser().parse(programInputStream), cfg); @SuppressWarnings("unused") Optional answerSet = solver.stream().findFirst(); // System.out.println(answerSet); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java index 19bf3f7e5..7782b110a 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java @@ -43,7 +43,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; @@ -101,7 +101,7 @@ public void testV300E300(SystemConfig cfg) { } private void testThreeColouring(int nVertices, int nEdges, SystemConfig cfg) { - InputProgram tmpPrg = new ProgramParserImpl().parse( + InputProgram tmpPrg = new ASPCore2ProgramParser().parse( "blue(N) :- v(N), not red(N), not green(N)." + "red(N) :- v(N), not blue(N), not green(N)." + "green(N) :- v(N), not red(N), not blue(N)." + diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java index 9f29deae8..550c34809 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java @@ -46,7 +46,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; @@ -187,7 +187,7 @@ public void testN101(SystemConfig cfg) { } private void testThreeColouring(int n, boolean shuffle, int seed, SystemConfig cfg) { - InputProgram tmpPrg = new ProgramParserImpl() + InputProgram tmpPrg = new ASPCore2ProgramParser() .parse("col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); InputProgramImpl.Builder prgBuilder = InputProgramImpl.builder().accumulate(tmpPrg); prgBuilder.addFacts(createColors("1", "2", "3")); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java index 554b6f8b5..a94f12ae5 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java @@ -44,7 +44,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; @@ -101,7 +101,7 @@ public void testN11(SystemConfig cfg) { } private void testThreeColouring(int n, SystemConfig cfg) { - InputProgram tmpPrg = new ProgramParserImpl().parse( + InputProgram tmpPrg = new ASPCore2ProgramParser().parse( "col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); From 50975873b28276ad29e411c7b7ce6e212029ca1a Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 10 Feb 2022 20:03:20 +0100 Subject: [PATCH 18/96] account for action heads in rewritings and rule translations --- .../transformation/VariableEqualityRemoval.java | 13 +++++++++++-- .../ac/tuwien/kr/alpha/core/rules/AbstractRule.java | 6 +++--- .../ac/tuwien/kr/alpha/core/rules/InternalRule.java | 2 +- .../tuwien/kr/alpha/core/rules/NormalRuleImpl.java | 13 +++---------- 4 files changed, 18 insertions(+), 16 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 3d74801a1..0086de1fe 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -42,6 +42,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.rules.heads.DisjunctiveHead; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; @@ -116,8 +117,16 @@ private Rule findAndReplaceVariableEquality(Rule rule) { if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } - // TODO handle action heads! - NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + + NormalHead head = (NormalHead) rule.getHead(); + NormalHead rewrittenHead; + // TODO can this be done nicer? + if(rule.getHead() instanceof ActionHead) { + ActionHead actHead = (ActionHead) head; + rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getAction(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); + } else { + rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + } // Use substitution for actual replacement. Unifier replacementSubstitution = new Unifier(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java index dad66bc2d..efa0d5785 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java @@ -27,7 +27,7 @@ public abstract class AbstractRule implements Rule { private final Set bodyLiteralsPositive; private final Set bodyLiteralsNegative; - public AbstractRule(H head, List body) { + public AbstractRule(H head, Set body) { this.head = head; Set positiveBody = new LinkedHashSet<>(); Set negativeBody = new LinkedHashSet<>(); @@ -49,8 +49,8 @@ public AbstractRule(H head, List body) { } } - public AbstractRule(H head, Set body) { - this(head, new ArrayList<>(body)); + public AbstractRule(H head, List body) { + this(head, new LinkedHashSet<>(body)); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java index 0df14b399..8e9e797f5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java @@ -98,7 +98,7 @@ public static void resetIdGenerator() { } public static CompiledRule fromNormalRule(Rule rule) { - return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new ArrayList<>(rule.getBody())); + return new InternalRule(rule.getHead(), new ArrayList<>(rule.getBody())); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java index 5283a6a6d..6f520bf63 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java @@ -1,6 +1,5 @@ package at.ac.tuwien.kr.alpha.core.rules; -import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -10,8 +9,6 @@ import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.util.Util; /** * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. @@ -30,14 +27,10 @@ public NormalRuleImpl(NormalHead head, Set body) { } public static NormalRuleImpl fromBasicRule(Rule rule) { - BasicAtom headAtom = null; - if (!rule.isConstraint()) { - if (!(rule.getHead() instanceof NormalHead)) { - throw Util.oops("Trying to construct a NormalRule from rule with non-normal head! Head type is: " + rule.getHead().getClass().getSimpleName()); - } - headAtom = ((NormalHead) rule.getHead()).getAtom(); + if(!(rule.getHead() instanceof NormalHead)) { + throw new IllegalArgumentException("Cannot create normal rule for unsupported head type " + rule.getHead().getClass().getSimpleName()); } - return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new ArrayList<>(rule.getBody())); + return new NormalRuleImpl((NormalHead) rule.getHead(), rule.getBody()); } public boolean isGround() { From b975a9cfb91954f7c5c93a7d14b87567d0016490 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 11 Feb 2022 13:27:16 +0100 Subject: [PATCH 19/96] refactoring: factory methods for rules --- .../tuwien/kr/alpha/api/rules/NormalRule.java | 2 + .../kr/alpha/commons}/rules/AbstractRule.java | 21 ++--- .../kr/alpha/commons}/rules/BasicRule.java | 15 ++-- .../alpha/commons}/rules/NormalRuleImpl.java | 21 +---- .../tuwien/kr/alpha/commons/rules/Rules.java | 46 ++++++++++ .../alpha/core/grounder/BridgedGrounder.java | 6 +- .../core/grounder/RuleGroundingOrderImpl.java | 4 +- .../alpha/core/grounder/bridges/Bridge.java | 4 +- .../LiteralInstantiationResult.java | 4 +- .../aspcore2/ASPCore2ParseTreeVisitor.java | 19 ++-- .../alpha/core/programs/InternalProgram.java | 10 +-- .../core/programs/NormalProgramImpl.java | 10 ++- .../ArithmeticTermsRewriting.java | 13 +-- .../transformation/ChoiceHeadToNormal.java | 14 +-- .../transformation/EnumerationRewriting.java | 8 +- .../IntervalTermToIntervalAtom.java | 8 +- .../transformation/PredicateInternalizer.java | 10 +-- .../VariableEqualityRemoval.java | 21 +++-- .../aggregates/AggregateLiteralSplitting.java | 22 ++--- .../AggregateOperatorNormalization.java | 22 ++--- .../aggregates/AggregateRewriting.java | 7 +- .../encoders/AbstractAggregateEncoder.java | 8 +- .../aggregates/encoders/MinMaxEncoder.java | 12 +-- .../StringtemplateBasedAggregateEncoder.java | 7 +- .../kr/alpha/core/rules/CompiledRule.java | 1 - ...nternalRule.java => CompiledRuleImpl.java} | 90 ++++++++++++++----- .../kr/alpha/core/rules/CompiledRules.java | 27 ++++++ .../ac/tuwien/kr/alpha/core/rules/Rules.java | 28 ------ .../kr/alpha/core/common/ProgramTest.java | 2 +- .../tuwien/kr/alpha/core/common/RuleTest.java | 15 ++-- .../GrounderMockWithBasicProgram.java | 9 +- .../core/grounder/GrounderMockWithChoice.java | 13 ++- .../alpha/core/grounder/SubstitutionTest.java | 6 +- .../RuleGroundingInfoTest.java | 24 ++--- .../alpha/core/solver/AtomCounterTests.java | 6 +- .../alpha/core/solver/ChoiceManagerTests.java | 4 +- .../AlphaHeuristicTestAssumptions.java | 12 +-- .../ac/tuwien/kr/alpha/RuleToStringTest.java | 11 +-- .../kr/alpha/api/impl/AlphaImplTest.java | 9 +- 39 files changed, 327 insertions(+), 244 deletions(-) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/rules/AbstractRule.java (87%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/rules/BasicRule.java (85%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/rules/NormalRuleImpl.java (54%) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/{InternalRule.java => CompiledRuleImpl.java} (74%) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/Rules.java rename alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/{grounder => rules}/RuleGroundingInfoTest.java (88%) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java index 5a5c995c6..fb0bef941 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java @@ -12,4 +12,6 @@ public interface NormalRule extends Rule { BasicAtom getHeadAtom(); + boolean isGround(); + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java similarity index 87% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java index efa0d5785..3431a637a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java @@ -1,9 +1,7 @@ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; -import java.util.ArrayList; import java.util.Collections; import java.util.LinkedHashSet; -import java.util.List; import java.util.Objects; import java.util.Set; @@ -21,13 +19,13 @@ * * Copyright (c) 2017-2019, the Alpha Team. */ -public abstract class AbstractRule implements Rule { +abstract class AbstractRule implements Rule { private final H head; private final Set bodyLiteralsPositive; private final Set bodyLiteralsNegative; - public AbstractRule(H head, Set body) { + AbstractRule(H head, Set body) { this.head = head; Set positiveBody = new LinkedHashSet<>(); Set negativeBody = new LinkedHashSet<>(); @@ -48,10 +46,6 @@ public AbstractRule(H head, Set body) { + "Notice: A rule is considered safe if all variables occurring in negative literals, builtin atoms, and the head of the rule also occur in some positive literal."); } } - - public AbstractRule(H head, List body) { - this(head, new LinkedHashSet<>(body)); - } /** * Checks whether a rule is safe. The actual safety condition may vary over the next improvements. Currently, a rule is @@ -127,13 +121,12 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof AbstractRule)) { + if (!(obj instanceof Rule)) { return false; } - AbstractRule other = (AbstractRule) obj; - return Objects.equals(this.bodyLiteralsNegative, other.bodyLiteralsNegative) - && Objects.equals(this.bodyLiteralsPositive, other.bodyLiteralsPositive) - && Objects.equals(this.head, other.head); + Rule other = (Rule) obj; + return Objects.equals(this.getBody(), other.getBody()) + && Objects.equals(this.head, other.getHead()); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java similarity index 85% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java index bc3076f85..64ee0daa5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java @@ -25,27 +25,24 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; -import java.util.Arrays; -import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; /** * Represents a non-ground rule or a constraint. A {@link BasicRule} has a general {@link Head}, meaning both choice heads and disjunctive * heads are permissible. * This implementation represents a rule after being parsed from a given ASP program, but before being transformed into a - * {@link NormalRuleImpl}. + * {@link NormalRule}. */ -public class BasicRule extends AbstractRule { +class BasicRule extends AbstractRule { - public BasicRule(Head head, List body) { + BasicRule(Head head, Set body) { super(head, body); } - public BasicRule(Head head, Literal... body) { - this(head, Arrays.asList(body)); - } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java similarity index 54% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java index 6f520bf63..6380c4e4a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java @@ -1,13 +1,10 @@ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; -import java.util.List; import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; /** @@ -16,23 +13,13 @@ * * Copyright (c) 2019, the Alpha Team. */ -public class NormalRuleImpl extends AbstractRule implements NormalRule { +class NormalRuleImpl extends AbstractRule implements NormalRule { - public NormalRuleImpl(NormalHead head, List body) { + NormalRuleImpl(NormalHead head, Set body) { super(head, body); } - public NormalRuleImpl(NormalHead head, Set body) { - super(head, body); - } - - public static NormalRuleImpl fromBasicRule(Rule rule) { - if(!(rule.getHead() instanceof NormalHead)) { - throw new IllegalArgumentException("Cannot create normal rule for unsupported head type " + rule.getHead().getClass().getSimpleName()); - } - return new NormalRuleImpl((NormalHead) rule.getHead(), rule.getBody()); - } - + @Override public boolean isGround() { if (!isConstraint() && !this.getHead().isGround()) { return false; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java new file mode 100644 index 000000000..c86cf9b46 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java @@ -0,0 +1,46 @@ +package at.ac.tuwien.kr.alpha.commons.rules; + +import java.util.LinkedHashSet; +import java.util.Set; + +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; + +public final class Rules { + + private Rules() { + throw new AssertionError("Cannot instantiate utility class!"); + } + + public static Rule newRule(BasicAtom headAtom, Literal... body) { + NormalHead head = Heads.newNormalHead(headAtom); + Set bodyLiterals = new LinkedHashSet<>(); + for (Literal lit : body) { + bodyLiterals.add(lit); + } + return Rules.newRule(head, bodyLiterals); + } + + public static Rule newRule(BasicAtom headAtom, Set body) { + NormalHead head = Heads.newNormalHead(headAtom); + return Rules.newRule(head, body); + } + + public static Rule newRule(Head head, Set body) { + return new BasicRule(head, body); + } + + public static Rule newConstraint(Set body) { + return new BasicRule(null, body); + } + + public static NormalRule newNormalRule(NormalHead head, Set body) { + return new NormalRuleImpl(head, body); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java index 406ced3b0..e81b3efef 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java @@ -8,7 +8,7 @@ import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.grounder.bridges.Bridge; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; public abstract class BridgedGrounder extends AbstractGrounder { protected final Bridge[] bridges; @@ -23,8 +23,8 @@ protected BridgedGrounder(Bridge... bridges) { this.bridges = bridges; } - protected Set collectExternalRules(Assignment assignment, AtomStore atomStore, IntIdGenerator intIdGenerator) { - Set collectedRules = new HashSet<>(); + protected Set collectExternalRules(Assignment assignment, AtomStore atomStore, IntIdGenerator intIdGenerator) { + Set collectedRules = new HashSet<>(); for (Bridge bridge : bridges) { collectedRules.addAll(bridge.getRules(assignment, atomStore, intIdGenerator)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java index bd7c8ffa1..145b66261 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java @@ -29,10 +29,10 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; /** - * A grounding order computed by {@link RuleGroundingInfoImpl} for a specific {@link InternalRule} and a specific starting literal. + * A grounding order computed by {@link RuleGroundingInfoImpl} for a specific {@link CompiledRuleImpl} and a specific starting literal. */ public class RuleGroundingOrderImpl implements RuleGroundingOrder{ diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java index 2d0beedb2..f2efd465a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java @@ -3,10 +3,10 @@ import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; import java.util.Collection; public interface Bridge { - Collection getRules(Assignment assignment, AtomStore atomStore, IntIdGenerator intIdGenerator); + Collection getRules(Assignment assignment, AtomStore atomStore, IntIdGenerator intIdGenerator); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java index 6d2506543..10d733523 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java @@ -35,7 +35,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; /** * Representation of the result of instantiating, i.e. finding ground instances for a literal, as performed by @@ -43,7 +43,7 @@ * * A {@link LiteralInstantiationResult} bundles obtained ground substitutions - or the lack thereof, if none exist for a given literal - * together with status information that can be used by a {@link Grounder} to determine how to proceed when grounding an - * {@link InternalRule}. + * {@link CompiledRuleImpl}. * * Copyright (c) 2020, the Alpha Team. */ diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java index d817b57d2..1bf6d8a1b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java @@ -27,10 +27,9 @@ */ package at.ac.tuwien.kr.alpha.core.parser.aspcore2; -import static java.util.Collections.emptyList; - import java.util.ArrayList; import java.util.Collections; +import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -69,6 +68,7 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; @@ -77,7 +77,6 @@ import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Copyright (c) 2016-2021, the Alpha Team. @@ -188,7 +187,7 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { programBuilder.addFact(((NormalHead) head).getAtom()); } else { // Treat facts with choice or disjunction in the head like a rule. - programBuilder.addRule(new BasicRule(head, emptyList())); + programBuilder.addRule(Rules.newRule(head, Collections.emptySet())); } return null; } @@ -196,14 +195,14 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { @Override public Object visitStatement_constraint(ASPCore2Parser.Statement_constraintContext ctx) { // CONS body DOT - programBuilder.addRule(new BasicRule(null, visitBody(ctx.body()))); + programBuilder.addRule(Rules.newConstraint(visitBody(ctx.body()))); return null; } @Override public Object visitStatement_rule(ASPCore2Parser.Statement_ruleContext ctx) { // head CONS body DOT - programBuilder.addRule(new BasicRule(visitHead(ctx.head()), visitBody(ctx.body()))); + programBuilder.addRule(Rules.newRule(visitHead(ctx.head()), visitBody(ctx.body()))); return null; } @@ -312,13 +311,13 @@ public Object visitDirective_enumeration(ASPCore2Parser.Directive_enumerationCon } @Override - public List visitBody(ASPCore2Parser.BodyContext ctx) { + public Set visitBody(ASPCore2Parser.BodyContext ctx) { // body : ( naf_literal | aggregate ) (COMMA body)?; if (ctx == null) { - return emptyList(); + return Collections.emptySet(); } - final List literals = new ArrayList<>(); + final Set literals = new LinkedHashSet<>(); do { if (ctx.naf_literal() != null) { literals.add(visitNaf_literal(ctx.naf_literal())); @@ -494,7 +493,7 @@ public BasicAtom visitClassical_literal(ASPCore2Parser.Classical_literalContext public List visitTerms(ASPCore2Parser.TermsContext ctx) { // terms : term (COMMA terms)?; if (ctx == null) { - return emptyList(); + return Collections.emptyList(); } final List terms = new ArrayList<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index bca2f97cc..1cc7517c3 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -18,8 +18,7 @@ import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.grounder.FactIntervalEvaluator; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * A program in the internal representation needed for grounder and solver, i.e.: rules must have normal heads, all @@ -50,7 +49,7 @@ static ImmutablePair, List> internalizeRulesAndFacts(No } facts.add(r.getHead().getAtom()); } else { - internalRules.add(InternalRule.fromNormalRule(r)); + internalRules.add(CompiledRules.newCompiledRule(r.getHead(), r.getBody())); } } return new ImmutablePair<>(internalRules, facts); @@ -100,10 +99,7 @@ public Map getRulesById() { } public NormalProgram toNormalProgram() { - List normalRules = new ArrayList<>(); - for (CompiledRule rule : getRules()) { - normalRules.add(new NormalRuleImpl(rule.getHead(), new ArrayList<>(rule.getBody()))); - } + List normalRules = new ArrayList<>(getRules()); return new NormalProgramImpl(normalRules, getFacts(), getInlineDirectives()); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java index ad65431e0..e18f72366 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java @@ -3,14 +3,15 @@ import java.util.ArrayList; import java.util.List; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; /** * A program that only contains NormalRules. @@ -26,7 +27,10 @@ public NormalProgramImpl(List rules, List facts, InlineDirecti public static NormalProgramImpl fromInputProgram(InputProgram inputProgram) { List normalRules = new ArrayList<>(); for (Rule r : inputProgram.getRules()) { - normalRules.add(NormalRuleImpl.fromBasicRule(r)); + if (!r.isConstraint() && !(r.getHead() instanceof NormalHead)) { + throw new IllegalArgumentException("Cannot create normal rule for unsupported head type " + r.getHead().getClass().getSimpleName()); + } + normalRules.add(Rules.newNormalRule((NormalHead) r.getHead(), r.getBody())); } return new NormalProgramImpl(normalRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index 026cde8c5..1a346527c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -1,7 +1,9 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -17,12 +19,12 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Transforms rules such that arithmetic terms only occur in comparison predicates. @@ -64,11 +66,12 @@ public NormalProgram apply(NormalProgram inputProgram) { private NormalRule rewriteRule(NormalRule inputProgramRule) { numArithmeticVariables = 0; // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; - List rewrittenBodyLiterals = new ArrayList<>(); + Set rewrittenBodyLiterals = new LinkedHashSet<>(); // Rewrite head. if (!inputProgramRule.isConstraint()) { BasicAtom headAtom = inputProgramRule.getHeadAtom(); if (containsArithmeticTermsToRewrite(headAtom)) { + // TODO handle action heads! rewrittenHead = Heads.newNormalHead((BasicAtom) rewriteAtom(headAtom, rewrittenBodyLiterals)); } else { rewrittenHead = inputProgramRule.getHead(); @@ -83,7 +86,7 @@ private NormalRule rewriteRule(NormalRule inputProgramRule) { } rewrittenBodyLiterals.add(rewriteAtom(literal.getAtom(), rewrittenBodyLiterals).toLiteral(!literal.isNegated())); } - return new NormalRuleImpl(rewrittenHead, rewrittenBodyLiterals); + return Rules.newNormalRule(rewrittenHead, rewrittenBodyLiterals); } /** @@ -108,7 +111,7 @@ private boolean containsArithmeticTermsToRewrite(NormalRule inputProgramRule) { return false; } - private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { + private Term rewriteArithmeticSubterms(Term term, Set bodyLiterals) { // Keep term as-is if it contains no ArithmeticTerm. if (!containsArithmeticTerm(term)) { return term; @@ -132,7 +135,7 @@ private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { } } - private Atom rewriteAtom(Atom atomToRewrite, List bodyLiterals) { + private Atom rewriteAtom(Atom atomToRewrite, Set bodyLiterals) { if (atomToRewrite instanceof ComparisonAtom) { throw Util.oops("Trying to rewrite ComparisonAtom."); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 6c20981d0..7a59afd45 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -29,7 +29,9 @@ import java.util.ArrayList; import java.util.Iterator; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; @@ -43,11 +45,11 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Copyright (c) 2017-2021, the Alpha Team. @@ -87,7 +89,7 @@ public InputProgram apply(InputProgram inputProgram) { // Construct common body to both rules. BasicAtom head = choiceElement.getChoiceAtom(); - List ruleBody = new ArrayList<>(rule.getBody()); + Set ruleBody = new LinkedHashSet<>(rule.getBody()); ruleBody.addAll(choiceElement.getConditionLiterals()); if (containsIntervalTerms(head)) { @@ -104,13 +106,13 @@ public InputProgram apply(InputProgram inputProgram) { BasicAtom negHead = Atoms.newBasicAtom(negPredicate, headTerms); // Construct two guessing rules. - List guessingRuleBodyWithNegHead = new ArrayList<>(ruleBody); + Set guessingRuleBodyWithNegHead = new LinkedHashSet<>(ruleBody); guessingRuleBodyWithNegHead.add(Atoms.newBasicAtom(head.getPredicate(), head.getTerms()).toLiteral(false)); - additionalRules.add(new BasicRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead)); + additionalRules.add(Rules.newRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead)); - List guessingRuleBodyWithHead = new ArrayList<>(ruleBody); + Set guessingRuleBodyWithHead = new LinkedHashSet<>(ruleBody); guessingRuleBodyWithHead.add(Atoms.newBasicAtom(negPredicate, headTerms).toLiteral(false)); - additionalRules.add(new BasicRule(Heads.newNormalHead(head), guessingRuleBodyWithHead)); + additionalRules.add(Rules.newRule(Heads.newNormalHead(head), guessingRuleBodyWithHead)); // TODO: when cardinality constraints are possible, process the boundaries by adding a constraint with a cardinality check. } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index f9498270e..8c9e67f1e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -4,8 +4,10 @@ import java.util.ArrayList; import java.util.Iterator; +import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; @@ -18,10 +20,10 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Rewrites the ordinary atom whose name is given in the input program by the enumeration directive #enum_atom_is into @@ -69,7 +71,7 @@ private List> rewriteRules(List> srcRules, Predicate enumP if (rule.getHead() != null && ((NormalHead) rule.getHead()).getAtom().getPredicate().equals(enumPredicate)) { throw oops("Atom declared as enumeration atom by directive occurs in head of the rule: " + rule); } - List modifiedBodyLiterals = new ArrayList<>(rule.getBody()); + Set modifiedBodyLiterals = new LinkedHashSet<>(rule.getBody()); Iterator rit = modifiedBodyLiterals.iterator(); LinkedList rewrittenLiterals = new LinkedList<>(); while (rit.hasNext()) { @@ -89,7 +91,7 @@ private List> rewriteRules(List> srcRules, Predicate enumP rewrittenLiterals.add(new EnumerationAtom(enumIdTerm, valueTerm, indexTerm).toLiteral()); } modifiedBodyLiterals.addAll(rewrittenLiterals); - rewrittenRules.add(new BasicRule(rule.getHead(), modifiedBodyLiterals)); + rewrittenRules.add(Rules.newRule(rule.getHead(), modifiedBodyLiterals)); } return rewrittenRules; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index fd523432b..e5b0f9abe 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -29,8 +29,10 @@ import java.util.ArrayList; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -43,12 +45,12 @@ import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.atoms.IntervalAtom; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Rewrites all interval terms in a rule into a new variable and an IntervalAtom. @@ -68,7 +70,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { // Collect all intervals and replace them with variables. Map intervalReplacements = new LinkedHashMap<>(); - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal literal : rule.getBody()) { Literal rewrittenLiteral = rewriteLiteral(literal, intervalReplacements); @@ -91,7 +93,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { for (Map.Entry interval : intervalReplacements.entrySet()) { rewrittenBody.add(new IntervalAtom(interval.getValue(), interval.getKey()).toLiteral()); } - return new NormalRuleImpl(rewrittenHead, rewrittenBody); + return Rules.newNormalRule(rewrittenHead, rewrittenBody); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 7662edff1..7c2fa2ae5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.List; +import java.util.LinkedHashSet; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; @@ -15,9 +15,9 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * @@ -63,7 +63,7 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String newHead = head; } } - List newBody = new ArrayList<>(); + Set newBody = new LinkedHashSet<>(); for (Literal bodyElement : rule.getBody()) { // Only rewrite BasicAtoms. if (bodyElement instanceof BasicLiteral) { @@ -77,7 +77,7 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String newBody.add(bodyElement); } } - return new BasicRule(newHead, newBody); + return Rules.newRule(newHead, newBody); } private static BasicAtom makePredicateInternal(BasicAtom atom) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 0086de1fe..79270bddc 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -36,6 +36,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -48,10 +49,10 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Removes variable equalities from rules by replacing one variable with the other. @@ -113,19 +114,21 @@ private Rule findAndReplaceVariableEquality(Rule rule) { return rule; } - List rewrittenBody = new ArrayList<>(rule.getBody()); + Set rewrittenBody = new LinkedHashSet<>(rule.getBody()); if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } NormalHead head = (NormalHead) rule.getHead(); - NormalHead rewrittenHead; + NormalHead rewrittenHead = null; // TODO can this be done nicer? - if(rule.getHead() instanceof ActionHead) { - ActionHead actHead = (ActionHead) head; - rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getAction(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); - } else { - rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + if (!rule.isConstraint()) { + if (rule.getHead() instanceof ActionHead) { + ActionHead actHead = (ActionHead) head; + rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getAction(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); + } else { + rewrittenHead = Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + } } // Use substitution for actual replacement. @@ -159,6 +162,6 @@ private Rule findAndReplaceVariableEquality(Rule rule) { headAtom.getTerms().set(i, replaced); } } - return new BasicRule(rewrittenHead, rewrittenBody); + return Rules.newRule(rewrittenHead, rewrittenBody); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java index 457d41daa..2bf7af96e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java @@ -2,7 +2,9 @@ import java.util.ArrayList; import java.util.Collections; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import org.apache.commons.lang3.tuple.ImmutablePair; @@ -14,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; /** * Splits aggregate literals with both "lower" and "upper" bound operators into literals with only one operator each. @@ -53,8 +55,8 @@ public static List> split(Rule sourceRule) { private static List> splitAggregatesInRule(Rule sourceRule) { // Rule contains some aggregates that need splitting. // Aggregates may require splitting in two literals, or in two rules. - List commonBodyLiterals = new ArrayList<>(); - List twoLiteralsSplitAggregates = new ArrayList<>(); + Set commonBodyLiterals = new LinkedHashSet<>(); + Set twoLiteralsSplitAggregates = new LinkedHashSet<>(); List> twoRulesSplitAggregates = new ArrayList<>(); // First, sort literals of the rule and also compute splitting. for (Literal literal : sourceRule.getBody()) { @@ -66,17 +68,17 @@ private static List> splitAggregatesInRule(Rule sourceRule) { } } // Second, compute rule bodies of splitting result. - List commonBody = new ArrayList<>(commonBodyLiterals); + Set commonBody = new LinkedHashSet<>(commonBodyLiterals); commonBody.addAll(twoLiteralsSplitAggregates); - List> rewrittenBodies = new ArrayList<>(); + List> rewrittenBodies = new ArrayList<>(); rewrittenBodies.add(commonBody); // Initialize list of rules with the common body. // For n twoRulesSplitAggregates we need 2^n rules, so // for each of the n pairs in twoRulesSplitAggregates we duplicate the list of rewritten bodies. for (ImmutablePair ruleSplitAggregate : twoRulesSplitAggregates) { int numBodiesBeforeDuplication = rewrittenBodies.size(); for (int i = 0; i < numBodiesBeforeDuplication; i++) { - List originalBody = rewrittenBodies.get(i); - List duplicatedBody = new ArrayList<>(originalBody); + Set originalBody = rewrittenBodies.get(i); + Set duplicatedBody = new LinkedHashSet<>(originalBody); // Extend bodies of original and duplicate with splitting results. originalBody.add(ruleSplitAggregate.left); duplicatedBody.add(ruleSplitAggregate.right); @@ -85,13 +87,13 @@ private static List> splitAggregatesInRule(Rule sourceRule) { } // Third, turn computed bodies into rules again. List> rewrittenRules = new ArrayList<>(); - for (List rewrittenBody : rewrittenBodies) { - rewrittenRules.add(new BasicRule(sourceRule.getHead(), rewrittenBody)); + for (Set rewrittenBody : rewrittenBodies) { + rewrittenRules.add(Rules.newRule(sourceRule.getHead(), rewrittenBody)); } return rewrittenRules; } - private static void splitCombinedAggregateLiteral(Literal literal, List twoLiteralsSplitAggregates, + private static void splitCombinedAggregateLiteral(Literal literal, Set twoLiteralsSplitAggregates, List> twoRulesSplitAggregates) { AggregateLiteral aggLit = (AggregateLiteral) literal; ImmutablePair splitAggregate = splitCombinedAggregateAtom(aggLit.getAtom()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java index 66d93a737..696777364 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java @@ -1,8 +1,8 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import java.util.ArrayList; import java.util.Collections; -import java.util.List; +import java.util.LinkedHashSet; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -19,8 +19,8 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Transforms an {@link InputProgram} such that, for all aggregate (body-)literals, only the comparison operators "=" @@ -53,35 +53,35 @@ private AggregateOperatorNormalization() { } public static Rule normalize(Rule rule) { - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal lit : rule.getBody()) { rewrittenBody.addAll(rewriteLiteral(lit)); } - return new BasicRule(rule.getHead(), rewrittenBody); + return Rules.newRule(rule.getHead(), rewrittenBody); } - private static List rewriteLiteral(Literal lit) { + private static Set rewriteLiteral(Literal lit) { if (lit instanceof AggregateLiteral) { return rewriteAggregateOperator((AggregateLiteral) lit); } else { - return Collections.singletonList(lit); + return Collections.singleton(lit); } } - private static List rewriteAggregateOperator(AggregateLiteral lit) { + private static Set rewriteAggregateOperator(AggregateLiteral lit) { AggregateAtom atom = lit.getAtom(); if (atom.getLowerBoundOperator() == null && atom.getUpperBoundOperator() != null) { return rewriteAggregateOperator(convertToLeftHandComparison(lit)); } if (lit.getAtom().getAggregateFunction() == AggregateFunctionSymbol.MIN || lit.getAtom().getAggregateFunction() == AggregateFunctionSymbol.MAX) { // No operator normalization needed for #min/#max aggregates. - return Collections.singletonList(lit); + return Collections.singleton(lit); } if (atom.getLowerBoundOperator().equals(ComparisonOperators.EQ) || atom.getLowerBoundOperator().equals(ComparisonOperators.LE)) { // Nothing to do for operator "=" or "<=". - return Collections.singletonList(lit); + return Collections.singleton(lit); } else { - List retVal = new ArrayList<>(); + Set retVal = new LinkedHashSet<>(); VariableTerm decrementedBound; ComparisonOperator lowerBoundOp = atom.getLowerBoundOperator(); if (lowerBoundOp.equals(ComparisonOperators.LT)) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java index da9352b3a..bd8761d08 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -16,6 +17,7 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -23,7 +25,6 @@ import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.CountEncoder; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.MinMaxEncoder; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.SumEncoder; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Rewrites {@link AggregateLiteral}s in programs to semantically equivalent, aggregate-free sub-programs. @@ -138,7 +139,7 @@ private AbstractAggregateEncoder getEncoderForAggregateFunction(AggregateFunctio private static List> rewriteRulesWithAggregates(AggregateRewritingContext ctx) { List> rewrittenRules = new ArrayList<>(); for (Rule rule : ctx.getRulesWithAggregates()) { - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal lit : rule.getBody()) { if (lit instanceof AggregateLiteral) { AggregateInfo aggregateInfo = ctx.getAggregateInfo((AggregateLiteral) lit); @@ -147,7 +148,7 @@ private static List> rewriteRulesWithAggregates(AggregateRewritingCon rewrittenBody.add(lit); } } - rewrittenRules.add(new BasicRule(rule.getHead(), rewrittenBody)); + rewrittenRules.add(Rules.newRule(rule.getHead(), rewrittenBody)); } return rewrittenRules; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index e609c3984..b09fe9b53 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -1,10 +1,12 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import org.apache.commons.collections4.ListUtils; +import org.apache.commons.collections4.SetUtils; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -19,13 +21,13 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.PredicateInternalizer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Abstract base class for aggregate encoders. An aggregate encoder provides an encoding for a given aggregate literal, @@ -104,8 +106,8 @@ public InputProgram encodeAggregateLiteral(AggregateInfo aggregateToEncode) { */ protected Rule encodeAggregateElement(AggregateInfo aggregateInfo, AggregateElement element) { BasicAtom headAtom = buildElementRuleHead(aggregateInfo.getId(), element, aggregateInfo.getAggregateArguments()); - return new BasicRule(Heads.newNormalHead(headAtom), - ListUtils.union(element.getElementLiterals(), new ArrayList<>(aggregateInfo.getDependencies()))); + return Rules.newRule(Heads.newNormalHead(headAtom), + SetUtils.union(new LinkedHashSet<>(element.getElementLiterals()), aggregateInfo.getDependencies())); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 9ecb6f0b2..e78acb4bd 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; -import java.util.List; +import java.util.LinkedHashSet; +import java.util.Set; import org.apache.commons.collections4.SetUtils; import org.stringtemplate.v4.ST; @@ -16,6 +16,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; @@ -23,12 +25,12 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; public class MinMaxEncoder extends AbstractAggregateEncoder { @@ -109,7 +111,7 @@ protected InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode) { */ NormalHead resultRuleHead = Heads.newNormalHead( Atoms.newBasicAtom(Predicates.getPredicate(resultName, 2), aggregateToEncode.getAggregateArguments(), atom.getLowerBoundTerm())); - List resultRuleBody = new ArrayList<>(); + Set resultRuleBody = new LinkedHashSet<>(); VariableTerm aggregateValue = Terms.newVariable("_AGG_VAL"); ComparisonLiteral aggregateValueComparison = Literals.fromAtom(Atoms.newComparisonAtom(atom.getLowerBoundTerm(), aggregateValue, cmpOp), true); Literal aggregateResult = Atoms.newBasicAtom(Predicates.getPredicate( @@ -119,7 +121,7 @@ protected InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode) { resultRuleBody.add(aggregateValueComparison); resultRuleBody.addAll(aggregateToEncode.getDependencies()); InputProgramImpl.Builder bld = InputProgramImpl.builder(parser.parse(encodingTemplate.render())); - BasicRule resultRule = new BasicRule(resultRuleHead, resultRuleBody); + Rule resultRule = Rules.newRule(resultRuleHead, resultRuleBody); bld.addRule(resultRule); return bld.build(); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index c025a6d55..5c1bbde5b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -1,6 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; import java.util.Collections; import org.apache.commons.collections4.ListUtils; @@ -16,13 +15,13 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationRewriting; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Abstract base class for aggregate encoders making use of stringtemplates in their rewriting workflow. @@ -96,13 +95,13 @@ private String getBoundPredicateName(String aggregateId) { private Rule buildZeroBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), Terms.newConstant(0)); - return new BasicRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), aggregateToEncode.getDependencies()); } private Rule buildBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), aggregateToEncode.getLiteral().getAtom().getLowerBoundTerm()); - return new BasicRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), aggregateToEncode.getDependencies()); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java index b15dfbc41..62ffa209b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java @@ -16,5 +16,4 @@ public interface CompiledRule extends NormalRule { CompiledRule renameVariables(String str); - boolean isGround(); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java similarity index 74% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java index 8e9e797f5..e12bf7693 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java @@ -28,8 +28,9 @@ package at.ac.tuwien.kr.alpha.core.rules; import java.util.ArrayList; -import java.util.Arrays; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import com.google.common.annotations.VisibleForTesting; @@ -37,9 +38,10 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.commons.terms.Terms; @@ -50,27 +52,23 @@ * Represents a normal rule or a constraint for the semi-naive grounder. * A normal rule has no head atom if it represents a constraint, otherwise it has one atom in its head. */ -public class InternalRule extends NormalRuleImpl implements CompiledRule { +public class CompiledRuleImpl implements CompiledRule { private static final IntIdGenerator ID_GENERATOR = new IntIdGenerator(); - private final int ruleId; + private final NormalRule wrappedRule; + private final int ruleId; private final List occurringPredicates; - private final RuleGroundingInfoImpl groundingOrders; - - public InternalRule(NormalHead head, Literal... body) { - this(head, Arrays.asList(body)); - } - public InternalRule(NormalHead head, List body) { - super(head, body); + CompiledRuleImpl(NormalHead head, Set body) { if (body.isEmpty()) { throw new IllegalArgumentException( "Empty bodies are not supported for InternalRule! (Head = " + (head == null ? "NULL" : head.getAtom().toString()) + ")"); } - this.ruleId = InternalRule.ID_GENERATOR.getNextId(); + this.ruleId = CompiledRuleImpl.ID_GENERATOR.getNextId(); + this.wrappedRule = Rules.newNormalRule(head, body); this.occurringPredicates = new ArrayList<>(); if (!isConstraint()) { @@ -84,21 +82,13 @@ public InternalRule(NormalHead head, List body) { this.occurringPredicates.add(literal.getPredicate()); } - // not needed, done in AbstractRule! Leaving it commented out for future reference since this might actually be the - // proper place to put it - // this.checkSafety(); - this.groundingOrders = new RuleGroundingInfoImpl(this); this.groundingOrders.computeGroundingOrders(); } @VisibleForTesting public static void resetIdGenerator() { - InternalRule.ID_GENERATOR.resetGenerator(); - } - - public static CompiledRule fromNormalRule(Rule rule) { - return new InternalRule(rule.getHead(), new ArrayList<>(rule.getBody())); + CompiledRuleImpl.ID_GENERATOR.resetGenerator(); } /** @@ -109,7 +99,7 @@ public static CompiledRule fromNormalRule(Rule rule) { * @return */ @Override - public InternalRule renameVariables(String newVariablePostfix) { + public CompiledRuleImpl renameVariables(String newVariablePostfix) { // TODO handle action heads! List occurringVariables = new ArrayList<>(); BasicAtom headAtom = this.getHeadAtom(); @@ -123,11 +113,13 @@ public InternalRule renameVariables(String newVariablePostfix) { variableReplacement.put(occurringVariable, Terms.newVariable(newVariableName)); } BasicAtom renamedHeadAtom = headAtom.substitute(variableReplacement); - ArrayList renamedBody = new ArrayList<>(this.getBody().size()); + Set renamedBody = new LinkedHashSet<>(this.getBody().size()); for (Literal literal : this.getBody()) { renamedBody.add(literal.substitute(variableReplacement)); } - return new InternalRule(Heads.newNormalHead(renamedHeadAtom), renamedBody); + // TODO action heads! + // TODO we want to pull renameVariables down to atom, term, etc level + return new CompiledRuleImpl(Heads.newNormalHead(renamedHeadAtom), renamedBody); } /** @@ -149,4 +141,54 @@ public int getRuleId() { return this.ruleId; } + @Override + public BasicAtom getHeadAtom() { + return wrappedRule.getHeadAtom(); + } + + @Override + public NormalHead getHead() { + return wrappedRule.getHead(); + } + + @Override + public Set getBody() { + return wrappedRule.getBody(); + } + + @Override + public boolean isConstraint() { + return wrappedRule.isConstraint(); + } + + @Override + public Set getPositiveBody() { + return wrappedRule.getPositiveBody(); + } + + @Override + public Set getNegativeBody() { + return wrappedRule.getNegativeBody(); + } + + @Override + public boolean isGround() { + return wrappedRule.isGround(); + } + + @Override + public String toString() { + return wrappedRule.toString(); + } + + @Override + public boolean equals(Object o) { + return wrappedRule.equals(o); + } + + @Override + public int hashCode() { + return wrappedRule.hashCode(); + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java new file mode 100644 index 000000000..baf96bfb5 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java @@ -0,0 +1,27 @@ +package at.ac.tuwien.kr.alpha.core.rules; + +import java.util.LinkedHashSet; +import java.util.Set; + +import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; + +public final class CompiledRules { + + private CompiledRules() { + throw new AssertionError("Cannot instantiate utility class!"); + } + + public static CompiledRule newCompiledRule(NormalHead head, Set body) { + return new CompiledRuleImpl(head, body); + } + + public static CompiledRule newCompiledRule(NormalHead head, Literal... body) { + Set bodySet = new LinkedHashSet<>(); + for (Literal lit : body) { + bodySet.add(lit); + } + return CompiledRules.newCompiledRule(head, bodySet); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/Rules.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/Rules.java deleted file mode 100644 index 7666ba84a..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/Rules.java +++ /dev/null @@ -1,28 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.rules; - -import java.util.ArrayList; -import java.util.List; - -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; - -public final class Rules { - - private Rules() { - throw new AssertionError("Cannot instantiate utility class!"); - } - - public static Rule newRule(BasicAtom headAtom, Literal... body) { - NormalHead head = Heads.newNormalHead(headAtom); - List bodyLiterals = new ArrayList<>(); - for (Literal lit : body) { - bodyLiterals.add(lit); - } - return new BasicRule(head, bodyLiterals); - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java index 0557fe2c4..b102d6fd3 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java @@ -40,9 +40,9 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.Rules; public class ProgramTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java index 9359bb09c..e63700042 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java @@ -13,11 +13,11 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; -import at.ac.tuwien.kr.alpha.core.rules.Rules; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * Copyright (c) 2018 - 2021, the Alpha Team. @@ -33,8 +33,8 @@ public void renameVariables() { BasicAtom bodyAtom3 = Atoms.newBasicAtom(Predicates.getPredicate("q", 3), Terms.newVariable("X"), Terms.newFunctionTerm("g", Terms.newVariable("Y")), Terms.newVariable("Z")); BasicAtom bodyAtom4 = Atoms.newBasicAtom(Predicates.getPredicate("dom", 1), Terms.newVariable("A")); - CompiledRule rule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule( - Rules.newRule(headAtom, bodyAtom1.toLiteral(), bodyAtom2.toLiteral(), bodyAtom3.toLiteral(), bodyAtom4.toLiteral()))); + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(headAtom), bodyAtom1.toLiteral(), bodyAtom2.toLiteral(), bodyAtom3.toLiteral(), + bodyAtom4.toLiteral()); // ruleWithRenamedVars := p(X_13, Y_13) :- a, f(Z_13) = 1, q(X_13, g(Y_13), Z_13), dom(A_13). BasicAtom headAtomRenamed = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X_13"), Terms.newVariable("Y_13")); @@ -44,9 +44,8 @@ public void renameVariables() { BasicAtom bodyAtom3Renamed = Atoms.newBasicAtom(Predicates.getPredicate("q", 3), Terms.newVariable("X_13"), Terms.newFunctionTerm("g", Terms.newVariable("Y_13")), Terms.newVariable("Z_13")); BasicAtom bodyAtom4Renamed = Atoms.newBasicAtom(Predicates.getPredicate("dom", 1), Terms.newVariable("A_13")); - CompiledRule ruleWithRenamedVars = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule( - Rules.newRule(headAtomRenamed, bodyAtom1Renamed.toLiteral(), bodyAtom2Renamed.toLiteral(), bodyAtom3Renamed.toLiteral(), - bodyAtom4Renamed.toLiteral()))); + CompiledRule ruleWithRenamedVars = CompiledRules.newCompiledRule(Heads.newNormalHead(headAtomRenamed), bodyAtom1Renamed.toLiteral(), + bodyAtom2Renamed.toLiteral(), bodyAtom3Renamed.toLiteral(), bodyAtom4Renamed.toLiteral()); assertEquals(ruleWithRenamedVars, rule.renameVariables("_13")); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java index 7950b90dd..20f176924 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java @@ -62,9 +62,8 @@ import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * Represents a small ASP program {@code { c :- a, b. a. b. }}. @@ -94,8 +93,8 @@ public class GrounderMockWithBasicProgram implements Grounder { private static Atom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("a", 0)); private static Atom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("b", 0)); private static BasicAtom atomCC = Atoms.newBasicAtom(Predicates.getPredicate("c", 0)); - private static BasicRule ruleABC = new BasicRule(Heads.newNormalHead(atomCC), Arrays.asList(atomAA.toLiteral(), atomBB.toLiteral())); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleABC)), new BasicSubstitution()); + private static CompiledRule ruleABC = CompiledRules.newCompiledRule(Heads.newNormalHead(atomCC), atomAA.toLiteral(), atomBB.toLiteral()); + private static Atom rule1 = new RuleAtom(ruleABC, new BasicSubstitution()); private Set returnedNogoods = new HashSet<>(); public GrounderMockWithBasicProgram(AtomStore atomStore) { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java index bda74f709..f548a1feb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java @@ -63,9 +63,8 @@ import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. @@ -116,10 +115,10 @@ public class GrounderMockWithChoice implements Grounder { ).collect(entriesToMap()); private static BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); private static BasicAtom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)); - private static BasicRule ruleAA = new BasicRule(Heads.newNormalHead(atomAA), Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); - private static BasicRule ruleBB = new BasicRule(Heads.newNormalHead(atomBB), Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false))); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleAA)), new BasicSubstitution()); - private static Atom rule2 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleBB)), new BasicSubstitution()); + private static CompiledRule ruleAA = CompiledRules.newCompiledRule(Heads.newNormalHead(atomAA), Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false)); + private static CompiledRule ruleBB = CompiledRules.newCompiledRule(Heads.newNormalHead(atomBB), Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false)); + private static Atom rule1 = new RuleAtom(ruleAA, new BasicSubstitution()); + private static Atom rule2 = new RuleAtom(ruleBB, new BasicSubstitution()); private static Atom atomEnBR1 = ChoiceAtom.on(1); private static Atom atomEnBR2 = ChoiceAtom.on(2); private static Atom atomDisBR1 = ChoiceAtom.off(3); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java index 24c2aceea..be0335ed0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java @@ -50,7 +50,7 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; import at.ac.tuwien.kr.alpha.core.test.util.SubstitutionTestUtil; import at.ac.tuwien.kr.alpha.core.util.Substitutions; @@ -109,7 +109,7 @@ public void substituteNegativeBasicAtom() { @Test public void groundAndPrintRule() { // rule := x :- p(X,Y), not q(X,Y). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("x", 0))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("x", 0))), Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("q", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(false)); Substitution substitution1 = BasicSubstitution.specializeSubstitution(PX, PA, BasicSubstitution.EMPTY_SUBSTITUTION); @@ -166,7 +166,7 @@ private void groundLiteralToString(boolean negated) { @Test public void substitutionFromString() { // rule := x :- p(X,Y), not q(X,Y). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("x", 0))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("x", 0))), Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("q", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(false)); Substitution substitution1 = BasicSubstitution.specializeSubstitution(PX, PA, BasicSubstitution.EMPTY_SUBSTITUTION); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java similarity index 88% rename from alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoTest.java rename to alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java index 4f95d0f2c..32df51f6f 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.grounder; +package at.ac.tuwien.kr.alpha.core.rules; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -41,8 +41,8 @@ import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; +import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; /** * Copyright (c) 2017-2021, the Alpha Team. @@ -52,7 +52,7 @@ public class RuleGroundingInfoTest { @Test public void groundingOrder() { // r1 := h(X,C) :- p(X,Y), q(A,B), r(Y,A), s(C). - CompiledRule r1 = new InternalRule( + CompiledRule r1 = CompiledRules.newCompiledRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 2), Terms.newVariable("X"), Terms.newVariable("C"))), Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("q", 2), Terms.newVariable("A"), Terms.newVariable("B")).toLiteral(), @@ -63,7 +63,7 @@ public void groundingOrder() { assertEquals(4, rgo1.getStartingLiterals().size()); // r2 := j(A,A,X,Y) :- r1(A,A), r1(X,Y), r1(A,X), r1(A,Y). - CompiledRule r2 = new InternalRule( + CompiledRule r2 = CompiledRules.newCompiledRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("j", 4), Terms.newVariable("A"), Terms.newVariable("A"), Terms.newVariable("X"), Terms.newVariable("Y"))), Atoms.newBasicAtom(Predicates.getPredicate("r1", 2), Terms.newVariable("A"), Terms.newVariable("A")).toLiteral(), @@ -75,7 +75,7 @@ public void groundingOrder() { assertEquals(4, rgo2.getStartingLiterals().size()); // r3 := p(a) :- b = a. - CompiledRule r3 = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("a"))), + CompiledRule r3 = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("a"))), Atoms.newComparisonAtom(Terms.newSymbolicConstant("b"), Terms.newSymbolicConstant("a"), ComparisonOperators.EQ).toLiteral()); RuleGroundingInfo rgo3 = new RuleGroundingInfoImpl(r3); rgo3.computeGroundingOrders(); @@ -90,7 +90,7 @@ public void groundingOrder() { public void groundingOrderUnsafe() { assertThrows(RuntimeException.class, () -> { // rule := h(X, Z) :- Y = X + 1, X = Z + 1, Z = Y - 2. - CompiledRule rule = new InternalRule( + CompiledRule rule = CompiledRules.newCompiledRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 2), Terms.newVariable("X"), Terms.newVariable("Z"))), Atoms.newComparisonAtom( Terms.newVariable("Y"), @@ -111,7 +111,7 @@ public void groundingOrderUnsafe() { @Test public void testPositionFromWhichAllVarsAreBound_ground() { // rule := a :- b, not c. - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 0))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b", 0)).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("c", 0)).toLiteral(false)); RuleGroundingInfo rgo0 = computeGroundingOrdersForRule(rule); @@ -121,7 +121,7 @@ public void testPositionFromWhichAllVarsAreBound_ground() { @Test public void testPositionFromWhichAllVarsAreBound_simpleNonGround() { // rule := a(X) :- b(X), not c(X). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("c", 1), Terms.newVariable("X")).toLiteral(false)); RuleGroundingInfo rgo0 = computeGroundingOrdersForRule(rule); @@ -134,7 +134,7 @@ public void testPositionFromWhichAllVarsAreBound_simpleNonGround() { @Test public void testPositionFromWhichAllVarsAreBound_longerSimpleNonGround() { // rule := a(X) :- b(X), c(X), d(X), not e(X). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("c", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("d", 1), Terms.newVariable("X")).toLiteral(), @@ -149,7 +149,7 @@ public void testPositionFromWhichAllVarsAreBound_longerSimpleNonGround() { @Test public void testToString_longerSimpleNonGround() { // rule := a(X) :- b(X), c(X), d(X), not e(X). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("c", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("d", 1), Terms.newVariable("X")).toLiteral(), @@ -176,7 +176,7 @@ public void testToString_longerSimpleNonGround() { @Test public void testPositionFromWhichAllVarsAreBound_joinedNonGround() { // rule := a(X) :- b(X), c(X, Y), d(X, Z), not e(X). - CompiledRule rule = new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), + CompiledRule rule = CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newVariable("X"))), Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newVariable("X")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("c", 2), Terms.newVariable("X"), Terms.newVariable("Y")).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("d", 2), Terms.newVariable("X"), Terms.newVariable("Z")).toLiteral(), diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java index f43a858e8..84f271a58 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java @@ -50,7 +50,7 @@ import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; // TODO should this be part of an AtomStoreTest?? public class AtomCounterTests { @@ -124,8 +124,8 @@ private void createChoiceAtom() { private void createRuleAtom() { BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); - CompiledRule ruleAA = new InternalRule(Heads.newNormalHead(atomAA), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); + CompiledRule ruleAA = CompiledRules.newCompiledRule(Heads.newNormalHead(atomAA), + Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false)); atomStore.putIfAbsent(new RuleAtom(ruleAA, new BasicSubstitution())); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java index 692e6840a..47a149456 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java @@ -45,7 +45,7 @@ import at.ac.tuwien.kr.alpha.core.grounder.NaiveGrounder; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; public class ChoiceManagerTests { private Grounder grounder; @@ -59,7 +59,7 @@ public void setUp() { * h :- b1, b2, not b3, not b4. */ CompiledProgram program = new InternalProgram(Collections.singletonList( - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 0))), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b1", 0)).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("b2", 0)).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("b3", 0)).toLiteral(false), diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java index 6102ee79f..98f16b08f 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java @@ -50,7 +50,7 @@ import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.NaiveNoGoodStore; import at.ac.tuwien.kr.alpha.core.solver.TrailAssignment; @@ -83,11 +83,11 @@ public void setUp() { */ List facts = Arrays.asList(Atoms.newBasicAtom(Predicates.getPredicate("b1", 0)), Atoms.newBasicAtom(Predicates.getPredicate("b2", 0))); List rules = Arrays.asList( - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("b3", 0))), Atoms.newBasicAtom(Predicates.getPredicate("nb3", 0)).toLiteral(false)), - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("nb3", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b3", 0)).toLiteral(false)), - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("b4", 0))), Atoms.newBasicAtom(Predicates.getPredicate("nb4", 0)).toLiteral(false)), - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("nb4", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b4", 0)).toLiteral(false)), - new InternalRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 0))), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("b3", 0))), Atoms.newBasicAtom(Predicates.getPredicate("nb3", 0)).toLiteral(false)), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("nb3", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b3", 0)).toLiteral(false)), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("b4", 0))), Atoms.newBasicAtom(Predicates.getPredicate("nb4", 0)).toLiteral(false)), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("nb4", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b4", 0)).toLiteral(false)), + CompiledRules.newCompiledRule(Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("h", 0))), Atoms.newBasicAtom(Predicates.getPredicate("b1", 0)).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("b2", 0)).toLiteral(), Atoms.newBasicAtom(Predicates.getPredicate("b3", 0)).toLiteral(false), diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index 1234baadc..aadbd8588 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -35,14 +35,14 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** - * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. + * Tests {@link BasicRule#toString()} and {@link CompiledRuleImpl#toString()}. */ public class RuleToStringTest { private final ProgramParser parser = new EvologProgramParser(); @@ -93,7 +93,8 @@ private void parseSingleRuleAndCheckToString(String rule) { } private void constructNonGroundRuleAndCheckToString(String textualRule) { - CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(parseSingleRule(textualRule))); + Rule parsedRule = parseSingleRule(textualRule); + CompiledRule nonGroundRule = CompiledRules.newCompiledRule((NormalHead) parsedRule.getHead(), parsedRule.getBody()); assertEquals(textualRule, nonGroundRule.toString()); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 4b3920483..668dee7bb 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -44,6 +44,7 @@ import java.nio.file.StandardOpenOption; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Optional; @@ -64,6 +65,8 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; @@ -72,13 +75,13 @@ import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.externals.MethodPredicateInterpretation; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; // TODO This is a functional test and should not be run with standard unit tests @@ -333,9 +336,9 @@ private static class SubThingy extends Thingy { public void withExternalSubtype() throws Exception { SubThingy thingy = new SubThingy(); - BasicRule rule = new BasicRule( + Rule rule = Rules.newRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newConstant("x"))), - singletonList(Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("thinger", 1), + Collections.singleton(Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("thinger", 1), new MethodPredicateInterpretation(this.getClass().getMethod("thinger", Thingy.class)), singletonList(Terms.newConstant(thingy)), emptyList()), true))); From b2f9c96daf915c8e53473b969e0e74a9a87b95f7 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 17 Feb 2022 15:41:49 +0100 Subject: [PATCH 20/96] actions: file output draft --- .../tuwien/kr/alpha/core/actions/Actions.java | 75 +++++++++++++++++++ .../core/actions/OutputStreamHandle.java | 49 ++++++++++++ .../parser/evolog/EvologParseTreeVisitor.java | 3 + 3 files changed, 127 insertions(+) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java index 5aff462d6..1c2890c4b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -1,13 +1,22 @@ package at.ac.tuwien.kr.alpha.core.actions; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; import java.util.List; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; public class Actions { + // TODO this needs to be encapsulated and made thread-safe! + private static final IntIdGenerator ID_GEN = new IntIdGenerator(); + public static FunctionTerm printLine(List input) { if (input.size() != 1) { // TODO do properly @@ -18,4 +27,70 @@ public static FunctionTerm printLine(List input) { return Terms.newFunctionTerm("ok"); } + public static FunctionTerm fileOpenOutputStream(List input) { + if (input.size() != 1) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + Term inTerm = input.get(0); + if (!(inTerm instanceof ConstantTerm)) { + throw new IllegalArgumentException("Input must be a string constant!"); + } + ConstantTerm inConst = (ConstantTerm) inTerm; + if (!(inConst.getObject() instanceof String) || inConst.isSymbolic()) { + throw new IllegalArgumentException("Input must be a string constant!"); + } + String path = (String) inConst.getObject(); + try { + OutputStreamHandle streamHandle = new OutputStreamHandle(ID_GEN.getNextId(), new FileOutputStream(path, true)); + return Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle)); + } catch (FileNotFoundException e) { + throw new RuntimeException(e); + } + } + + @SuppressWarnings("unchecked") + public static FunctionTerm outputStreamWrite(List input) { + if (input.size() != 2) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof OutputStreamHandle)) { + throw new IllegalArgumentException("First input term must be an output stream handle!"); + } + OutputStreamHandle dstHandle = ((ConstantTerm) input.get(0)).getObject(); + if (!(input.get(1) instanceof ConstantTerm) || !(((ConstantTerm) input.get(1)).getObject() instanceof String) + || ((ConstantTerm) input.get(1)).isSymbolic()) { + throw new IllegalArgumentException("Second input term must be a string constant!"); + } + String str = ((ConstantTerm) input.get(1)).getObject(); + // TODO this needs some built-in conversion function + byte[] data = str.getBytes(); + OutputStream dst = dstHandle.getStream(); + try { + dst.write(data); + return Terms.newFunctionTerm("ok"); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } + + @SuppressWarnings("unchecked") + public static FunctionTerm outputStreamClose(List input) { + if (input.size() != 1) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof OutputStreamHandle)) { + throw new IllegalArgumentException("First input term must be an output stream handle!"); + } + OutputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); + try { + handle.getStream().close(); + return Terms.newFunctionTerm("ok"); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java new file mode 100644 index 000000000..827403bdb --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java @@ -0,0 +1,49 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.io.OutputStream; + +public class OutputStreamHandle implements Comparable { + + private final int id; + private final OutputStream stream; + + public OutputStreamHandle(int id, OutputStream stream) { + this.id = id; + this.stream = stream; + } + + public int getId() { + return id; + } + + public OutputStream getStream() { + return stream; + } + + @Override + public String toString() { + return "outputStream-" + id; + } + + @Override + public int compareTo(OutputStreamHandle other) { + return this.id - other.id; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } else if (!(o instanceof OutputStreamHandle)) { + return false; + } + OutputStreamHandle other = (OutputStreamHandle) o; + return this.id == other.id; + } + + @Override + public int hashCode() { + return this.id; + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java index bf10553cc..f39c923b7 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java @@ -22,6 +22,9 @@ public class EvologParseTreeVisitor extends ASPCore2ParseTreeVisitor { public EvologParseTreeVisitor(Map externals, boolean acceptVariables) { super(externals, acceptVariables); actionRegistry.put("printLine", Actions::printLine); + actionRegistry.put("fileOutputStream", Actions::fileOpenOutputStream); + actionRegistry.put("streamWrite", Actions::outputStreamWrite); + actionRegistry.put("streamClose", Actions::outputStreamClose); } public EvologParseTreeVisitor(Map externals) { From 09e1b7ced8e653bd201c4a94a2392106cb0ad61a Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 17 Feb 2022 22:32:58 +0100 Subject: [PATCH 21/96] actions: file input draft --- .../tuwien/kr/alpha/core/actions/Actions.java | 69 ++++++++++++++++++- .../alpha/core/actions/InputStreamHandle.java | 49 +++++++++++++ .../core/actions/OutputStreamHandle.java | 1 + .../parser/evolog/EvologParseTreeVisitor.java | 7 +- .../transformation/StratifiedEvaluation.java | 12 +--- 5 files changed, 125 insertions(+), 13 deletions(-) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java index 1c2890c4b..72a138b8b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -4,6 +4,8 @@ import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; +import java.nio.file.Files; +import java.nio.file.Paths; import java.util.List; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; @@ -92,5 +94,70 @@ public static FunctionTerm outputStreamClose(List input) { throw new RuntimeException(ex); } } - + + public static FunctionTerm fileOpenInputStream(List input) { + if (input.size() != 1) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + Term inTerm = input.get(0); + if (!(inTerm instanceof ConstantTerm)) { + throw new IllegalArgumentException("Input must be a string constant!"); + } + ConstantTerm inConst = (ConstantTerm) inTerm; + if (!(inConst.getObject() instanceof String) || inConst.isSymbolic()) { + throw new IllegalArgumentException("Input must be a string constant!"); + } + String path = (String) inConst.getObject(); + try { + InputStreamHandle streamHandle = new InputStreamHandle(ID_GEN.getNextId(), Files.newBufferedReader(Paths.get(path))); + return Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle)); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } + + @SuppressWarnings("unchecked") + public static FunctionTerm inputStreamReadLine(List input) { + if (input.size() != 1) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof InputStreamHandle)) { + throw new IllegalArgumentException("First input term must be an input stream handle!"); + } + InputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); + try { + String line = handle.getStream().readLine(); + ConstantTerm lineTerm; + if (line == null) { + // we reached EOF + lineTerm = Terms.newSymbolicConstant("eof"); + } else { + lineTerm = Terms.newConstant(line); + } + return Terms.newFunctionTerm("ok", lineTerm); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } + + @SuppressWarnings("unchecked") + public static FunctionTerm inputStreamClose(List input) { + if (input.size() != 1) { + // TODO do properly + throw new IllegalArgumentException("Incorrect arity!"); + } + if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof InputStreamHandle)) { + throw new IllegalArgumentException("First input term must be an input stream handle!"); + } + InputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); + try { + handle.getStream().close(); + return Terms.newFunctionTerm("ok"); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java new file mode 100644 index 000000000..ee2805d25 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java @@ -0,0 +1,49 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.io.BufferedReader; + +public class InputStreamHandle implements Comparable { + + private final int id; + private final BufferedReader stream; + + public InputStreamHandle(int id, BufferedReader stream) { + this.id = id; + this.stream = stream; + } + + public int getId() { + return id; + } + + public BufferedReader getStream() { + return stream; + } + + @Override + public String toString() { + return "outputStream-" + id; + } + + @Override + public int compareTo(InputStreamHandle other) { + return this.id - other.id; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } else if (!(o instanceof InputStreamHandle)) { + return false; + } + InputStreamHandle other = (InputStreamHandle) o; + return this.id == other.id; + } + + @Override + public int hashCode() { + return this.id; + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java index 827403bdb..edbb19184 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java @@ -2,6 +2,7 @@ import java.io.OutputStream; +// TODO change this to wrap a PrintStream public class OutputStreamHandle implements Comparable { private final int id; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java index f39c923b7..02c9983a5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java @@ -22,9 +22,14 @@ public class EvologParseTreeVisitor extends ASPCore2ParseTreeVisitor { public EvologParseTreeVisitor(Map externals, boolean acceptVariables) { super(externals, acceptVariables); actionRegistry.put("printLine", Actions::printLine); + actionRegistry.put("fileOutputStream", Actions::fileOpenOutputStream); actionRegistry.put("streamWrite", Actions::outputStreamWrite); - actionRegistry.put("streamClose", Actions::outputStreamClose); + actionRegistry.put("outputStreamClose", Actions::outputStreamClose); + + actionRegistry.put("fileInputStream", Actions::fileOpenInputStream); + actionRegistry.put("streamReadLine", Actions::inputStreamReadLine); + actionRegistry.put("inputStreamClose", Actions::inputStreamClose); } public EvologParseTreeVisitor(Map externals) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 379c86875..34d8047fe 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -341,17 +341,7 @@ public BasicAtom instantiateActionHead(ActionHead head, Substitution substitutio List substitutedInput = new ArrayList<>(); // Substitute all variables in action input so that all input terms are ground. for (Term inputTerm : actionInput) { - // TODO handle variables nested in function terms as well! - if (inputTerm instanceof VariableTerm) { - VariableTerm inputVar = (VariableTerm) inputTerm; - if (!substitution.isVariableSet(inputVar)) { - throw new IllegalStateException( - "No substitute for action input variable " + inputVar.toString() + " in substitution: " + substitution.toString()); - } - substitutedInput.add(inputVar.substitute(substitution)); - } else { - substitutedInput.add(inputTerm); - } + substitutedInput.add(inputTerm.substitute(substitution)); } // Call the actual action. // TODO exception handling (translate EVERY throwable to an error term) From 21664edd79d5b554d13a3dd1e2b06aa1ab4697d9 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 24 Feb 2022 15:21:01 +0100 Subject: [PATCH 22/96] additional actions for input stream handling --- .../commons/externals/AspStandardLibrary.java | 31 +++++++++++++++++++ .../tuwien/kr/alpha/core/actions/Actions.java | 6 ++-- .../alpha/core/actions/InputStreamHandle.java | 2 +- .../transformation/StratifiedEvaluation.java | 1 - 4 files changed, 35 insertions(+), 5 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java index 14142ed62..ee757b46e 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java @@ -211,4 +211,35 @@ public static Set>> stringConcat(String s1, String s2) return Collections.singleton(Terms.asTermList(s1 + s2)); } + /** + * Converts the given string to an integer + */ + @Predicate(name = "string_parse_integer") + public static Set>> stringParseInteger(String str) { + return Collections.singleton(Collections.singletonList(Terms.newConstant(Integer.valueOf(str)))); + } + + @Predicate(name = "string_is_empty") + public static boolean isStringEmpty(String str) { + return str.isEmpty(); + } + + @Predicate(name = "string_substring") + public static Set>> substringOfString(String str, int startIdx, int endIdx) { + return Collections.singleton(Collections.singletonList(Terms.newConstant(str.substring(startIdx, endIdx)))); + } + + @Predicate(name = "str_x_xs") + public static Set>> stringHeadRemainder(String str) { + List> xXs = null; + if (str.isEmpty()) { + return Collections.emptySet(); + } else if (str.length() == 1) { + xXs = List.of(Terms.newConstant(str), Terms.newConstant("")); + } else { + xXs = List.of(Terms.newConstant(str.substring(0, 1)), Terms.newConstant(str.substring(1, str.length()))); + } + return Collections.singleton(xXs); + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java index 72a138b8b..22643cccf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -71,7 +71,7 @@ public static FunctionTerm outputStreamWrite(List input) { OutputStream dst = dstHandle.getStream(); try { dst.write(data); - return Terms.newFunctionTerm("ok"); + return Terms.newFunctionTerm("writeResult", Terms.newSymbolicConstant("ok")); } catch (IOException ex) { throw new RuntimeException(ex); } @@ -89,7 +89,7 @@ public static FunctionTerm outputStreamClose(List input) { OutputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); try { handle.getStream().close(); - return Terms.newFunctionTerm("ok"); + return Terms.newFunctionTerm("closeResult", Terms.newSymbolicConstant("ok")); } catch (IOException ex) { throw new RuntimeException(ex); } @@ -154,7 +154,7 @@ public static FunctionTerm inputStreamClose(List input) { InputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); try { handle.getStream().close(); - return Terms.newFunctionTerm("ok"); + return Terms.newFunctionTerm("closeResult", Terms.newSymbolicConstant("ok")); } catch (IOException ex) { throw new RuntimeException(ex); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java index ee2805d25..3064ec249 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java @@ -22,7 +22,7 @@ public BufferedReader getStream() { @Override public String toString() { - return "outputStream-" + id; + return "inputStream-" + id; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 34d8047fe..87e77df1d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -30,7 +30,6 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; From 4f9de69b95a9c6c30bd394a1bb873713562a40a9 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 8 Mar 2022 21:34:09 +0100 Subject: [PATCH 23/96] actions: draft implementation --- .../kr/alpha/api/rules/heads/ActionHead.java | 3 +- .../commons/rules/heads/ActionHeadImpl.java | 11 +- .../kr/alpha/commons/rules/heads/Heads.java | 5 +- .../kr/alpha/core/actions/ActionContext.java | 12 ++ .../alpha/core/actions/ActionContextImpl.java | 108 ++++++++++++++++++ .../kr/alpha/core/actions/ActionWitness.java | 44 +++++++ .../parser/evolog/EvologParseTreeVisitor.java | 19 +-- .../transformation/PredicateInternalizer.java | 2 +- .../transformation/StratifiedEvaluation.java | 23 ++-- .../VariableEqualityRemoval.java | 2 +- .../kr/alpha/api/impl/AlphaFactory.java | 7 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 9 +- 12 files changed, 201 insertions(+), 44 deletions(-) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java index 1bc4c2674..d30cb726f 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ActionHead.java @@ -2,13 +2,12 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; public interface ActionHead extends NormalHead { - Action getAction(); + String getActionName(); List getActionInputTerms(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java index a7310a771..f64ca535b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java @@ -4,7 +4,6 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.rules.RuleInstantiator; import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; @@ -14,13 +13,13 @@ class ActionHeadImpl implements ActionHead { private final BasicAtom atom; - private final Action action; + private final String actionName; private final List actionInputTerms; private final VariableTerm actionOutputTerm; - ActionHeadImpl(BasicAtom atom, Action action, List actionInputTerms, VariableTerm actionOutputTerm) { + ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { this.atom = atom; - this.action = action; + this.actionName = actionName; this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); this.actionOutputTerm = actionOutputTerm; } @@ -42,8 +41,8 @@ public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substit } @Override - public Action getAction() { - return action; + public String getActionName() { + return actionName; } @Override diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java index 860ca5ee7..c3df8e6b9 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java @@ -3,7 +3,6 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; @@ -33,7 +32,7 @@ public static ChoiceElement newChoiceElement(BasicAtom choiceAtom, List return new ChoiceElementImpl(choiceAtom, conditionLiterals); } - public static ActionHead newActionHead(BasicAtom atom, Action action, List actionInputTerms, VariableTerm actionResult) { - return new ActionHeadImpl(atom, action, actionInputTerms, actionResult); + public static ActionHead newActionHead(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionResult) { + return new ActionHeadImpl(atom, actionName, actionInputTerms, actionResult); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java new file mode 100644 index 000000000..bbcca297e --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java @@ -0,0 +1,12 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +public interface ActionContext { + + ActionWitness execute(String actionName, int sourceRuleId, Substitution sourceRuleInstance, List inputTerms); + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java new file mode 100644 index 000000000..bfe5cc745 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java @@ -0,0 +1,108 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +public class ActionContextImpl implements ActionContext { + + // TODO initialize from outside + private final Map actions = new HashMap<>(); + private final Map actionRecord = new HashMap<>(); + + public ActionContextImpl() { + actions.put("printLine", Actions::printLine); + actions.put("fileOutputStream", Actions::fileOpenOutputStream); + actions.put("streamWrite", Actions::outputStreamWrite); + actions.put("outputStreamClose", Actions::outputStreamClose); + + actions.put("fileInputStream", Actions::fileOpenInputStream); + actions.put("streamReadLine", Actions::inputStreamReadLine); + actions.put("inputStreamClose", Actions::inputStreamClose); + } + + @Override + public ActionWitness execute(String actionName, int sourceRuleId, Substitution sourceRuleInstance, List inputTerms) { + // TODO maybe we want to stuff the whole action head plus substitution in here and do the whole instantiation here? + ActionInput actInput = new ActionInput(actionName, sourceRuleId, sourceRuleInstance, inputTerms); + return actionRecord.computeIfAbsent(actInput, this::execute); + } + + private ActionWitness execute(ActionInput input) { + Action action = actions.get(input.name); + FunctionTerm result = action.execute(input.inputTerms); + return new ActionWitness(input.sourceRule, input.instance, input.name, input.inputTerms, result); + } + + private static class ActionInput { + + private final String name; + private final int sourceRule; + private final Substitution instance; + private final List inputTerms; + + public ActionInput(String name, int sourceRule, Substitution instance, List inputTerms) { + this.name = name; + this.sourceRule = sourceRule; + this.instance = instance; + this.inputTerms = inputTerms; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((inputTerms == null) ? 0 : inputTerms.hashCode()); + result = prime * result + ((instance == null) ? 0 : instance.hashCode()); + result = prime * result + ((name == null) ? 0 : name.hashCode()); + result = prime * result + sourceRule; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ActionInput other = (ActionInput) obj; + if (inputTerms == null) { + if (other.inputTerms != null) { + return false; + } + } else if (!inputTerms.equals(other.inputTerms)) { + return false; + } + if (instance == null) { + if (other.instance != null) { + return false; + } + } else if (!instance.equals(other.instance)) { + return false; + } + if (name == null) { + if (other.name != null) { + return false; + } + } else if (!name.equals(other.name)) { + return false; + } + if (sourceRule != other.sourceRule) { + return false; + } + return true; + } + + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java new file mode 100644 index 000000000..ffa885726 --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java @@ -0,0 +1,44 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +public class ActionWitness { + + private final int ruleId; + private final Substitution groundBody; + private final String actionName; + private final List actionInput; + private final Term actionResult; + + public ActionWitness(int ruleId, Substitution groundBody, String actionName, List actionInput, Term actionResult) { + this.ruleId = ruleId; + this.groundBody = groundBody; + this.actionName = actionName; + this.actionInput = actionInput; + this.actionResult = actionResult; + } + + public int getRuleId() { + return ruleId; + } + + public Substitution getGroundBody() { + return groundBody; + } + + public String getActionName() { + return actionName; + } + + public List getActionInput() { + return actionInput; + } + + public Term getActionResult() { + return actionResult; + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java index 02c9983a5..2093d5da1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java @@ -1,35 +1,21 @@ package at.ac.tuwien.kr.alpha.core.parser.evolog; -import java.util.HashMap; import java.util.List; import java.util.Map; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.core.actions.Actions; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ParseTreeVisitor; public class EvologParseTreeVisitor extends ASPCore2ParseTreeVisitor { - private final Map actionRegistry = new HashMap<>(); - public EvologParseTreeVisitor(Map externals, boolean acceptVariables) { super(externals, acceptVariables); - actionRegistry.put("printLine", Actions::printLine); - - actionRegistry.put("fileOutputStream", Actions::fileOpenOutputStream); - actionRegistry.put("streamWrite", Actions::outputStreamWrite); - actionRegistry.put("outputStreamClose", Actions::outputStreamClose); - - actionRegistry.put("fileInputStream", Actions::fileOpenInputStream); - actionRegistry.put("streamReadLine", Actions::inputStreamReadLine); - actionRegistry.put("inputStreamClose", Actions::inputStreamClose); } public EvologParseTreeVisitor(Map externals) { @@ -41,11 +27,8 @@ public Head visitAction(ASPCore2Parser.ActionContext ctx) { BasicAtom atom = visitClassical_literal(ctx.classical_literal()); VariableTerm actionResultTerm = visitVariable_term(ctx.variable_term()); String actionId = ctx.ID().getText(); - if (!actionRegistry.containsKey(actionId)) { - throw new UnsupportedOperationException("Could not resolve action name " + actionId); - } List actionInputTerms = visitTerms(ctx.terms()); - return Heads.newActionHead(atom, actionRegistry.get(actionId), actionInputTerms, actionResultTerm); + return Heads.newActionHead(atom, actionId, actionInputTerms, actionResultTerm); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 7c2fa2ae5..f7570c7e0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -54,7 +54,7 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String // TODO do this nicely (using visitor?) if (head instanceof ActionHead) { ActionHead actionHead = (ActionHead) head; - newHead = Heads.newActionHead(makePredicateInternal(actionHead.getAtom()), actionHead.getAction(), actionHead.getActionInputTerms(), + newHead = Heads.newActionHead(makePredicateInternal(actionHead.getAtom()), actionHead.getActionName(), actionHead.getActionInputTerms(), actionHead.getActionOutputTerm()); } else { newHead = Heads.newNormalHead(makePredicateInternal(head.getAtom())); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 87e77df1d..2e99a7752 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -18,7 +18,6 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -28,11 +27,12 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.rules.heads.InstantiableHead; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; +import at.ac.tuwien.kr.alpha.core.actions.ActionContext; +import at.ac.tuwien.kr.alpha.core.actions.ActionWitness; import at.ac.tuwien.kr.alpha.core.depgraph.StratificationAlgorithm; import at.ac.tuwien.kr.alpha.core.grounder.IndexedInstanceStorage; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; @@ -64,6 +64,11 @@ public class StratifiedEvaluation extends ProgramTransformation solvedRuleIds = new HashSet<>(); // Set of rules that have been completely evaluated. private LiteralInstantiator literalInstantiator; + private ActionContext actionContext; + + public StratifiedEvaluation(ActionContext actionContext) { + this.actionContext = actionContext; + } @Override // Note: ideally this returns a "PartiallyEvaluatedProgram" such that the grounder can directly use the working @@ -312,7 +317,7 @@ private void fireRule(CompiledRule rule, Substitution substitution) { // BasicAtom newAtom = this.instantiate(rule.getHead(), substitution); BasicAtom newAtom; if (rule.getHead() instanceof ActionHead) { - newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution); + newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution, rule.getRuleId()); } else { newAtom = instantiateNormalHead(rule.getHead(), substitution); } @@ -334,21 +339,19 @@ public BasicAtom instantiateNormalHead(NormalHead head, Substitution substitutio } // FIXME should be dispatched via visitor pattern - public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution) { - // TODO ensure unique action only gets executed once! + public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution, int ruleId) { List actionInput = head.getActionInputTerms(); List substitutedInput = new ArrayList<>(); // Substitute all variables in action input so that all input terms are ground. for (Term inputTerm : actionInput) { substitutedInput.add(inputTerm.substitute(substitution)); } - // Call the actual action. - // TODO exception handling (translate EVERY throwable to an error term) - Action action = head.getAction(); - FunctionTerm actionResult = action.execute(substitutedInput); + // Delegate action execution to respctive backend. + ActionWitness witness = actionContext.execute(head.getActionName(), ruleId, substitution, substitutedInput); + // TODO if the according debug flag is set, convert witness to atom and add to facts. // We have an action result. Add it to the substitution as the substitute for the variable bound to the action so we're able to obtain the // ground BasicAtom derived by the rule - substitution.put(head.getActionOutputTerm(), actionResult); + substitution.put(head.getActionOutputTerm(), witness.getActionResult()); return head.getAtom().substitute(substitution); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 79270bddc..9ccad4d9f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -125,7 +125,7 @@ private Rule findAndReplaceVariableEquality(Rule rule) { if (!rule.isConstraint()) { if (rule.getHead() instanceof ActionHead) { ActionHead actHead = (ActionHead) head; - rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getAction(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); + rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getActionName(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); } else { rewrittenHead = Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index b0e89d72e..e55b55d22 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -8,6 +8,8 @@ import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.core.actions.ActionContext; +import at.ac.tuwien.kr.alpha.core.actions.ActionContextImpl; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; @@ -66,8 +68,11 @@ public static Alpha newAlpha(SystemConfig cfg) { .build()); SolverFactory solverFactory = new SolverFactory(cfg.getSolverName(), cfg.getNogoodStoreName(), solverCfg); + // Create an action context + ActionContext aCtx = new ActionContextImpl(); + // Now that all dependencies are taken care of, build new Alpha instance. - return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, cfg.isEvaluateStratifiedPart(), + return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, aCtx, cfg.isEvaluateStratifiedPart(), cfg.isSortAnswerSets()); } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index f2106fb5e..121f642c1 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -59,6 +59,7 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.commons.util.Util; +import at.ac.tuwien.kr.alpha.core.actions.ActionContext; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; @@ -81,17 +82,21 @@ public class AlphaImpl implements Alpha { private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; + private final ActionContext actionContext; + private final boolean enableStratifiedEvaluation; private final boolean sortAnswerSets; AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, GrounderFactory grounderFactory, SolverFactory solverFactory, + ActionContext actionContext, boolean enableStratifiedEvaluation, boolean sortAnswerSets) { this.parserFactory = parserFactory; this.programNormalizationFactory = programNormalizationFactory; this.grounderFactory = grounderFactory; this.solverFactory = solverFactory; + this.actionContext = actionContext; this.enableStratifiedEvaluation = enableStratifiedEvaluation; this.sortAnswerSets = sortAnswerSets; } @@ -158,7 +163,7 @@ InternalProgram performProgramPreprocessing(NormalProgram program) { AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); // TODO as Evolog moves further along, we want to integrate stratified evaluation with grounder and solver. // Therefore, leave it as is and don't make part of factory API for now. - retVal = new StratifiedEvaluation().apply(analyzed); + retVal = new StratifiedEvaluation(actionContext).apply(analyzed); } return retVal; } @@ -246,7 +251,7 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; if (enableStratifiedEvaluation) { - preprocessed = new StratifiedEvaluation().apply(analyzed).toNormalProgram(); + preprocessed = new StratifiedEvaluation(actionContext).apply(analyzed).toNormalProgram(); } else { preprocessed = program; } From 0f2fe31e45b5e967773b905f05feb6b8eb921b17 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 8 Mar 2022 21:59:01 +0100 Subject: [PATCH 24/96] remove useage of non-java-8-api --- .../kr/alpha/commons/externals/AspStandardLibrary.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java index ee757b46e..c88a7d12a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java @@ -27,6 +27,7 @@ import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; @@ -231,13 +232,15 @@ public static Set>> substringOfString(String str, int @Predicate(name = "str_x_xs") public static Set>> stringHeadRemainder(String str) { - List> xXs = null; + List> xXs = new ArrayList<>(); if (str.isEmpty()) { return Collections.emptySet(); } else if (str.length() == 1) { - xXs = List.of(Terms.newConstant(str), Terms.newConstant("")); + xXs.add(Terms.newConstant(str)); + xXs.add(Terms.newConstant("")); } else { - xXs = List.of(Terms.newConstant(str.substring(0, 1)), Terms.newConstant(str.substring(1, str.length()))); + xXs.add(Terms.newConstant(str.substring(0, 1))); + xXs.add(Terms.newConstant(str.substring(1, str.length()))); } return Collections.singleton(xXs); } From 7f8ba4f26e5ceb4356999b8aa47758232e469794 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 10 Mar 2022 10:43:11 +0100 Subject: [PATCH 25/96] unit tests for new standard library externals --- .../commons/externals/AspStandardLibrary.java | 19 +++++++- .../externals/AspStandardLibraryTest.java | 47 +++++++++++++++++++ 2 files changed, 64 insertions(+), 2 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java index c88a7d12a..392eed880 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibrary.java @@ -32,6 +32,9 @@ import java.util.List; import java.util.Set; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; @@ -48,6 +51,8 @@ */ public final class AspStandardLibrary { + private static final Logger LOGGER = LoggerFactory.getLogger(AspStandardLibrary.class); + private AspStandardLibrary() { throw new AssertionError(this.getClass().getSimpleName() + " is a non-instantiable utility class!"); } @@ -217,7 +222,12 @@ public static Set>> stringConcat(String s1, String s2) */ @Predicate(name = "string_parse_integer") public static Set>> stringParseInteger(String str) { - return Collections.singleton(Collections.singletonList(Terms.newConstant(Integer.valueOf(str)))); + try { + return Collections.singleton(Collections.singletonList(Terms.newConstant(Integer.valueOf(str)))); + } catch (NumberFormatException ex) { + LOGGER.warn("Not a valid integer value: {}", str); + return Collections.emptySet(); + } } @Predicate(name = "string_is_empty") @@ -227,7 +237,12 @@ public static boolean isStringEmpty(String str) { @Predicate(name = "string_substring") public static Set>> substringOfString(String str, int startIdx, int endIdx) { - return Collections.singleton(Collections.singletonList(Terms.newConstant(str.substring(startIdx, endIdx)))); + try { + return Collections.singleton(Collections.singletonList(Terms.newConstant(str.substring(startIdx, endIdx)))); + } catch (StringIndexOutOfBoundsException ex) { + LOGGER.warn("Invalid range for substring: {}, start {}, end {}", str, startIdx, endIdx); + return Collections.emptySet(); + } } @Predicate(name = "str_x_xs") diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibraryTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibraryTest.java index 75efaa200..ef11ffd28 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibraryTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/externals/AspStandardLibraryTest.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Set; +import java.util.function.Function; import org.junit.jupiter.api.Test; @@ -104,4 +105,50 @@ public void stringConcat() { assertEquals(Terms.newConstant("Foobar"), concat); } + @Test + public void stringParseValidInteger() { + Set>> result = AspStandardLibrary.stringParseInteger("123"); + assertEquals(1, result.size()); + List> intTerms = result.stream().findFirst().get(); + assertEquals(1, intTerms.size()); + Integer value = intTerms.get(0).getObject(); + assertEquals(123, value); + } + + @Test + public void stringParseInvalidInteger() { + assertTrue(AspStandardLibrary.stringParseInteger("bla").isEmpty()); + } + + @Test + public void stringEmpty() { + assertTrue(AspStandardLibrary.isStringEmpty("")); + assertFalse(AspStandardLibrary.isStringEmpty("bla")); + } + + @Test + public void substringValidRange() { + Set>> result = AspStandardLibrary.substringOfString("hahaha", 1, 4); + assertEquals(1, result.size()); + List> terms = result.stream().findFirst().get(); + assertEquals(1, terms.size()); + String substr = terms.get(0).getObject(); + assertEquals("aha", substr); + } + + @Test + public void substringInvalidRange() { + assertTrue(AspStandardLibrary.substringOfString("foo", 1, 0).isEmpty()); + } + + @Test + public void stringGetHead() { + Function>>, String> extractString = (set) -> { + return set.stream().findFirst().get().get(0).getObject(); + }; + assertTrue(AspStandardLibrary.stringHeadRemainder("").isEmpty()); + assertEquals("x", extractString.apply(AspStandardLibrary.stringHeadRemainder("x"))); + assertEquals("x", extractString.apply(AspStandardLibrary.stringHeadRemainder("xy"))); + } + } From 25008a4dd50f4f841b286b1902b70ee50eb167d0 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 10 Mar 2022 13:53:57 +0100 Subject: [PATCH 26/96] adapt AlphaFactory to work with externally supplied action bindings --- .../alpha/core/actions/ActionContextImpl.java | 13 ++--- .../tuwien/kr/alpha/core/actions/Actions.java | 16 ++++++ .../kr/alpha/api/impl/AlphaFactory.java | 47 ++++++++++++----- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 51 +++++++++++++++++++ 4 files changed, 104 insertions(+), 23 deletions(-) create mode 100644 alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java index bfe5cc745..2d570cf38 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java @@ -12,18 +12,11 @@ public class ActionContextImpl implements ActionContext { // TODO initialize from outside - private final Map actions = new HashMap<>(); + private final Map actions; private final Map actionRecord = new HashMap<>(); - public ActionContextImpl() { - actions.put("printLine", Actions::printLine); - actions.put("fileOutputStream", Actions::fileOpenOutputStream); - actions.put("streamWrite", Actions::outputStreamWrite); - actions.put("outputStreamClose", Actions::outputStreamClose); - - actions.put("fileInputStream", Actions::fileOpenInputStream); - actions.put("streamReadLine", Actions::inputStreamReadLine); - actions.put("inputStreamClose", Actions::inputStreamClose); + public ActionContextImpl(Map actions) { + this.actions = actions; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java index 22643cccf..391a6a1b7 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -6,8 +6,11 @@ import java.io.OutputStream; import java.nio.file.Files; import java.nio.file.Paths; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; @@ -16,6 +19,19 @@ public class Actions { + public static Map getDefaultActionBindings() { + Map actions = new HashMap<>(); + actions.put("printLine", Actions::printLine); + actions.put("fileOutputStream", Actions::fileOpenOutputStream); + actions.put("streamWrite", Actions::outputStreamWrite); + actions.put("outputStreamClose", Actions::outputStreamClose); + + actions.put("fileInputStream", Actions::fileOpenInputStream); + actions.put("streamReadLine", Actions::inputStreamReadLine); + actions.put("inputStreamClose", Actions::inputStreamClose); + return actions; + } + // TODO this needs to be encapsulated and made thread-safe! private static final IntIdGenerator ID_GEN = new IntIdGenerator(); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index e55b55d22..5c331c055 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -2,7 +2,10 @@ import java.util.function.Supplier; +import com.google.common.annotations.VisibleForTesting; + import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -10,6 +13,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.core.actions.ActionContext; import at.ac.tuwien.kr.alpha.core.actions.ActionContextImpl; +import at.ac.tuwien.kr.alpha.core.actions.Actions; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; @@ -27,14 +31,12 @@ private AlphaFactory() { throw new AssertionError("Cannot instantiate utility class!"); } - public static Alpha newAlpha(SystemConfig cfg) { - // Parser factory - Supply correct parser dependent on the accepted input language. - Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); - + static Supplier> newProgramNormalizationFactory(Supplier parserFactory, + AggregateRewritingConfig aggregateCfg) { // AggregateEncoderFactory depends on parser factory since stringtemplate-based aggregate encoders need to use the same parser that's used // for input programs. AggregateEncoderFactory aggregateEncoderFactory = new AggregateEncoderFactory(parserFactory, - cfg.getAggregateRewritingConfig().isUseSortingGridEncoding(), cfg.getAggregateRewritingConfig().isSupportNegativeValuesInSums()); + aggregateCfg.isUseSortingGridEncoding(), aggregateCfg.isSupportNegativeValuesInSums()); // Factory for aggregate rewriting (depends on encoders provided by above factory). Supplier aggregateRewritingFactory = () -> new AggregateRewriting(aggregateEncoderFactory.newCountEqualsEncoder(), @@ -43,18 +45,20 @@ public static Alpha newAlpha(SystemConfig cfg) { // Factory for NormalizeProgramTransformation - needs a supplier for AggregateRewriting due to AggregateRewritings' dependency to encoder // factory. - Supplier> programNormalizationFactory = () -> new NormalizeProgramTransformation( + return () -> new NormalizeProgramTransformation( aggregateRewritingFactory); + } - // GrounderFactory - Since every grounder instance is only good for one program instance, we need a factory. + static GrounderFactory newGrounderFactory(SystemConfig cfg) { GrounderHeuristicsConfiguration grounderHeuristicsCfg = GrounderHeuristicsConfiguration.getInstance(cfg.getGrounderToleranceConstraints(), cfg.getGrounderToleranceRules()); grounderHeuristicsCfg.setAccumulatorEnabled(cfg.isGrounderAccumulatorEnabled()); - GrounderFactory grounderFactory = new GrounderFactory( + return new GrounderFactory( grounderHeuristicsCfg, cfg.isDebugInternalChecks()); + } - // SolverFactory - Same as for GrounderFactory, we need a new Solver for each program. + static SolverFactory newSolverFactory(SystemConfig cfg) { SolverConfig solverCfg = new SolverConfig(); solverCfg.setDisableJustifications(cfg.isDisableJustificationSearch()); solverCfg.setDisableNogoodDeletion(cfg.isDisableNoGoodDeletion()); @@ -66,16 +70,33 @@ public static Alpha newAlpha(SystemConfig cfg) { .setMomsStrategy(cfg.getMomsStrategy()) .setReplayChoices(cfg.getReplayChoices()) .build()); - SolverFactory solverFactory = new SolverFactory(cfg.getSolverName(), cfg.getNogoodStoreName(), solverCfg); + return new SolverFactory(cfg.getSolverName(), cfg.getNogoodStoreName(), solverCfg); + } - // Create an action context - ActionContext aCtx = new ActionContextImpl(); + // TODO lifetime of one ActionContext needs to be exactly runtime ofone program! + @VisibleForTesting + public static Alpha newAlpha(SystemConfig cfg, ActionContext actionContext) { + // Parser factory - Supply correct parser dependent on the accepted input language. + Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); + Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, + cfg.getAggregateRewritingConfig()); + // GrounderFactory - Since every grounder instance is only good for one program instance, we need a factory. + GrounderFactory grounderFactory = newGrounderFactory(cfg); + + // SolverFactory - Same as for GrounderFactory, we need a new Solver for each program. + SolverFactory solverFactory = newSolverFactory(cfg); + // Now that all dependencies are taken care of, build new Alpha instance. - return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, aCtx, cfg.isEvaluateStratifiedPart(), + return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, actionContext, cfg.isEvaluateStratifiedPart(), cfg.isSortAnswerSets()); } + public static Alpha newAlpha(SystemConfig cfg) { + return newAlpha(cfg, new ActionContextImpl(Actions.getDefaultActionBindings())); + } + + // Create Alpha instance with default config. public static Alpha newAlpha() { return newAlpha(new SystemConfig()); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java new file mode 100644 index 000000000..09d23b500 --- /dev/null +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -0,0 +1,51 @@ +package at.ac.tuwien.kr.alpha; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +public class ActionsTest { + + private static class MockActionBindings { + + /* + Map actions = new HashMap<>(); + actions.put("printLine", Actions::printLine); + actions.put("fileOutputStream", Actions::fileOpenOutputStream); + actions.put("streamWrite", Actions::outputStreamWrite); + actions.put("outputStreamClose", Actions::outputStreamClose); + + actions.put("fileInputStream", Actions::fileOpenInputStream); + actions.put("streamReadLine", Actions::inputStreamReadLine); + actions.put("inputStreamClose", Actions::inputStreamClose); + return actions; + */ + + public FunctionTerm fileOpenOutputStream(List input) { + return null; + } + + public FunctionTerm outputStreamWrite(List input) { + return null; + } + + public FunctionTerm outputStreamClose(List input) { + return null; + } + + public FunctionTerm fileOpenInputStream(List input) { + return null; + } + + public FunctionTerm inputStreamReadLine(List input) { + return null; + } + + public FunctionTerm inputStreamClose(List inputStream) { + return null; + } + + } + +} From da7160d312bef24363c98a1f21ace552386015cf Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 7 Jul 2022 13:33:06 +0200 Subject: [PATCH 27/96] WIP: refine action implementation --- .../kr/alpha/core/actions/IOResult.java | 70 +++++++++++++++++++ .../at/ac/tuwien/kr/alpha/ActionsTest.java | 32 +++++---- 2 files changed, 90 insertions(+), 12 deletions(-) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java new file mode 100644 index 000000000..dce13429d --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java @@ -0,0 +1,70 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; + +public class IOResult implements FunctionTerm { + + private final Optional value; + private final Optional> error; + + public boolean isSuccess() { + return value.isPresent(); + } + + public boolean isError() { + return error.isPresent(); + } + + @Override + public boolean isGround() { + return true; + } + + @Override + public Set getOccurringVariables() { + return Collections.emptySet(); + } + + @Override + public Term substitute(Substitution substitution) { + return this; + } + + @Override + public Term renameVariables(String renamePrefix) { + return this; + } + + @Override + public Term normalizeVariables(String renamePrefix, RenameCounter counter) { + return this; + } + + @Override + public int compareTo(Term arg0) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public List getTerms() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String getSymbol() { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 09d23b500..f4e2a31c4 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,28 +1,36 @@ package at.ac.tuwien.kr.alpha; +import java.util.HashMap; import java.util.List; +import java.util.Map; + +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; public class ActionsTest { - + private static class MockActionBindings { - /* - Map actions = new HashMap<>(); - actions.put("printLine", Actions::printLine); - actions.put("fileOutputStream", Actions::fileOpenOutputStream); - actions.put("streamWrite", Actions::outputStreamWrite); - actions.put("outputStreamClose", Actions::outputStreamClose); + static final Logger LOGGER = LoggerFactory.getLogger(MockActionBindings.class); - actions.put("fileInputStream", Actions::fileOpenInputStream); - actions.put("streamReadLine", Actions::inputStreamReadLine); - actions.put("inputStreamClose", Actions::inputStreamClose); - return actions; - */ + Map, Integer> fileOpenOutputStreamInvocations = new HashMap<>(); + Map, Integer> outputStreamWriteInvocations = new HashMap<>(); + Map, Integer> outputStreamCloseInvocations = new HashMap<>(); + Map, Integer> fileOpenInputStreamInvocations = new HashMap<>(); + Map, Integer> inputStreamReadLineInvocations = new HashMap<>(); + Map, Integer> inputStreamCloseInvocations = new HashMap<>(); public FunctionTerm fileOpenOutputStream(List input) { + if (fileOpenOutputStreamInvocations.containsKey(input)) { + fileOpenOutputStreamInvocations.put(input, fileOpenOutputStreamInvocations.get(input) + 1); + } else { + fileOpenOutputStreamInvocations.put(input, 1); + } + LOGGER.info("Action fileOpenOutputStream({})", StringUtils.join(input, ", ")); return null; } From 625a3d0744e026e4434a57a55dbdf446f09e5b7b Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 25 Aug 2022 09:48:33 +0200 Subject: [PATCH 28/96] add ActionResultTerm interface and implementations --- .../kr/alpha/api/terms/ActionResultTerm.java | 29 ++++++++ .../terms/AbstractActionResultTerm.java | 26 +++++++ .../alpha/commons/terms/ActionErrorTerm.java | 24 +++++++ .../commons/terms/ActionSuccessTerm.java | 25 +++++++ .../alpha/commons/terms/FunctionTermImpl.java | 3 +- .../tuwien/kr/alpha/commons/terms/Terms.java | 9 +++ .../kr/alpha/core/actions/IOResult.java | 70 ------------------- 7 files changed, 115 insertions(+), 71 deletions(-) create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ActionResultTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractActionResultTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionErrorTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionSuccessTerm.java delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ActionResultTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ActionResultTerm.java new file mode 100644 index 000000000..7f6539bfa --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ActionResultTerm.java @@ -0,0 +1,29 @@ +package at.ac.tuwien.kr.alpha.api.terms; + +/** + * A term representing the result of an evolog action (i.e. result of action function application). + * Action result terms are function terms with symbol "success" or "error" depending on whether the corresponding action was sucessful. + * There is always one argument which is either some term representing the actual function result or an error message, respectively. + */ +public interface ActionResultTerm extends FunctionTerm { + + public static final String SUCCESS_SYMBOL = "success"; + public static final String ERROR_SYMBOL = "error"; + + /** + * True if the action that generated this result was successful (i.e. executed normally). + */ + boolean isSuccess(); + + /** + * True if the action that generated this result failed (i.e. threw an error in execution). + */ + boolean isError(); + + /** + * Gets the actual value wrapped in this result. + * Either a term representing the action return value or a string term representing an error + * message.s + */ + T getValue(); +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractActionResultTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractActionResultTerm.java new file mode 100644 index 000000000..4fba074cb --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractActionResultTerm.java @@ -0,0 +1,26 @@ +package at.ac.tuwien.kr.alpha.commons.terms; + +import java.util.Collections; + +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; + +abstract class AbstractActionResultTerm extends FunctionTermImpl implements ActionResultTerm { + + AbstractActionResultTerm(String symbol, T value) { + super(symbol, Collections.singletonList(value)); + } + + public abstract boolean isSuccess(); + + public boolean isError() { + return !isSuccess(); + } + + // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. + @SuppressWarnings("unchecked") + public T getValue() { + return (T) getTerms().get(0); + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionErrorTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionErrorTerm.java new file mode 100644 index 000000000..7bc4431b0 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionErrorTerm.java @@ -0,0 +1,24 @@ +package at.ac.tuwien.kr.alpha.commons.terms; + +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionErrorTerm extends AbstractActionResultTerm> { + + private static final Interner INTERNER = new Interner<>(); + + ActionErrorTerm(ConstantTerm value) { + super(ActionResultTerm.ERROR_SYMBOL, value); + } + + public static ActionErrorTerm getInstance(ConstantTerm term) { + return INTERNER.intern(new ActionErrorTerm(term)); + } + + @Override + public boolean isSuccess() { + return false; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionSuccessTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionSuccessTerm.java new file mode 100644 index 000000000..2502de56f --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ActionSuccessTerm.java @@ -0,0 +1,25 @@ +package at.ac.tuwien.kr.alpha.commons.terms; + +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionSuccessTerm extends AbstractActionResultTerm { + + private static final Interner> INTERNER = new Interner<>(); + + ActionSuccessTerm(T value) { + super(ActionResultTerm.SUCCESS_SYMBOL, value); + } + + @SuppressWarnings("unchecked") + public static ActionSuccessTerm getInstance(T term) { + return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); + } + + @Override + public boolean isSuccess() { + return true; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java index 14b8535de..694905e48 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java @@ -18,13 +18,14 @@ * Copyright (c) 2016-2017, the Alpha Team. */ class FunctionTermImpl extends AbstractTerm implements FunctionTerm { + private static final Interner INTERNER = new Interner<>(); private final String symbol; private final List terms; private final boolean ground; - private FunctionTermImpl(String symbol, List terms) { + FunctionTermImpl(String symbol, List terms) { if (symbol == null) { throw new IllegalArgumentException(); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java index b02e00c7b..8a361df6f 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java @@ -5,6 +5,7 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; @@ -65,6 +66,14 @@ public static Term newMinusTerm(Term negatedTerm) { return MinusTerm.getInstance(negatedTerm); } + public static ActionResultTerm actionSuccess(T value) { + return ActionSuccessTerm.getInstance(value); + } + + public static ActionResultTerm> actionError(String errMsg) { + return ActionErrorTerm.getInstance(Terms.newConstant(errMsg)); + } + @SafeVarargs public static > List> asTermList(T... values) { List> retVal = new ArrayList<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java deleted file mode 100644 index dce13429d..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/IOResult.java +++ /dev/null @@ -1,70 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.actions; - -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import java.util.Set; - -import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; - -public class IOResult implements FunctionTerm { - - private final Optional value; - private final Optional> error; - - public boolean isSuccess() { - return value.isPresent(); - } - - public boolean isError() { - return error.isPresent(); - } - - @Override - public boolean isGround() { - return true; - } - - @Override - public Set getOccurringVariables() { - return Collections.emptySet(); - } - - @Override - public Term substitute(Substitution substitution) { - return this; - } - - @Override - public Term renameVariables(String renamePrefix) { - return this; - } - - @Override - public Term normalizeVariables(String renamePrefix, RenameCounter counter) { - return this; - } - - @Override - public int compareTo(Term arg0) { - // TODO Auto-generated method stub - return 0; - } - - @Override - public List getTerms() { - // TODO Auto-generated method stub - return null; - } - - @Override - public String getSymbol() { - // TODO Auto-generated method stub - return null; - } - -} From 990da899b52132053552e0f7f6ec2d9ed060613d Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 26 Aug 2022 14:51:42 +0200 Subject: [PATCH 29/96] use ActionResultTerm interface in Action implementations --- .../kr/alpha/api/programs/actions/Action.java | 4 +- .../tuwien/kr/alpha/core/actions/Actions.java | 81 +++++++++---------- .../transformation/StratifiedEvaluation.java | 2 +- .../kr/alpha/api/impl/AlphaFactory.java | 2 +- 4 files changed, 41 insertions(+), 48 deletions(-) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java index 4c4b350b9..5b0ab32e1 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java @@ -2,7 +2,7 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; /** @@ -17,6 +17,6 @@ public interface Action { * @param input a list of (ground) terms constituting the input of the action * @return a function term representing the result of executing the action */ - FunctionTerm execute(List input); + ActionResultTerm execute(List input); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java index 391a6a1b7..a914f8523 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java @@ -11,8 +11,8 @@ import java.util.Map; import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; @@ -35,51 +35,48 @@ public static Map getDefaultActionBindings() { // TODO this needs to be encapsulated and made thread-safe! private static final IntIdGenerator ID_GEN = new IntIdGenerator(); - public static FunctionTerm printLine(List input) { + public static ActionResultTerm> printLine(List input) { if (input.size() != 1) { - // TODO do properly - throw new RuntimeException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } // TODO this should only work on ConstantTerm System.out.println(input.get(0).toString()); - return Terms.newFunctionTerm("ok"); + return Terms.actionSuccess(Terms.newSymbolicConstant("ok")); } - public static FunctionTerm fileOpenOutputStream(List input) { + public static ActionResultTerm fileOpenOutputStream(List input) { if (input.size() != 1) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } Term inTerm = input.get(0); if (!(inTerm instanceof ConstantTerm)) { - throw new IllegalArgumentException("Input must be a string constant!"); + return Terms.actionError("Input must be a string constant!"); } ConstantTerm inConst = (ConstantTerm) inTerm; if (!(inConst.getObject() instanceof String) || inConst.isSymbolic()) { - throw new IllegalArgumentException("Input must be a string constant!"); + return Terms.actionError("Input must be a string constant!"); } String path = (String) inConst.getObject(); try { OutputStreamHandle streamHandle = new OutputStreamHandle(ID_GEN.getNextId(), new FileOutputStream(path, true)); - return Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle)); + return Terms.actionSuccess(Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle))); } catch (FileNotFoundException e) { - throw new RuntimeException(e); + return Terms.actionError("File not found: " + path); } } @SuppressWarnings("unchecked") - public static FunctionTerm outputStreamWrite(List input) { + public static ActionResultTerm> outputStreamWrite(List input) { if (input.size() != 2) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof OutputStreamHandle)) { - throw new IllegalArgumentException("First input term must be an output stream handle!"); + return Terms.actionError("First input term must be an output stream handle!"); } OutputStreamHandle dstHandle = ((ConstantTerm) input.get(0)).getObject(); if (!(input.get(1) instanceof ConstantTerm) || !(((ConstantTerm) input.get(1)).getObject() instanceof String) || ((ConstantTerm) input.get(1)).isSymbolic()) { - throw new IllegalArgumentException("Second input term must be a string constant!"); + return Terms.actionError("Second input term must be a string constant!"); } String str = ((ConstantTerm) input.get(1)).getObject(); // TODO this needs some built-in conversion function @@ -87,60 +84,57 @@ public static FunctionTerm outputStreamWrite(List input) { OutputStream dst = dstHandle.getStream(); try { dst.write(data); - return Terms.newFunctionTerm("writeResult", Terms.newSymbolicConstant("ok")); + return Terms.actionSuccess(Terms.newSymbolicConstant("ok")); } catch (IOException ex) { - throw new RuntimeException(ex); + return Terms.actionError("Error writing data: " + ex.getMessage()); } } @SuppressWarnings("unchecked") - public static FunctionTerm outputStreamClose(List input) { + public static ActionResultTerm> outputStreamClose(List input) { if (input.size() != 1) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof OutputStreamHandle)) { - throw new IllegalArgumentException("First input term must be an output stream handle!"); + return Terms.actionError("First input term must be an output stream handle!"); } OutputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); try { handle.getStream().close(); - return Terms.newFunctionTerm("closeResult", Terms.newSymbolicConstant("ok")); + return Terms.actionSuccess(Terms.newSymbolicConstant("ok")); } catch (IOException ex) { - throw new RuntimeException(ex); + return Terms.actionError("Error closing stream: " + ex.getMessage()); } } - public static FunctionTerm fileOpenInputStream(List input) { + public static ActionResultTerm fileOpenInputStream(List input) { if (input.size() != 1) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } Term inTerm = input.get(0); if (!(inTerm instanceof ConstantTerm)) { - throw new IllegalArgumentException("Input must be a string constant!"); + return Terms.actionError("Input must be a string constant!"); } ConstantTerm inConst = (ConstantTerm) inTerm; if (!(inConst.getObject() instanceof String) || inConst.isSymbolic()) { - throw new IllegalArgumentException("Input must be a string constant!"); + return Terms.actionError("Input must be a string constant!"); } String path = (String) inConst.getObject(); try { InputStreamHandle streamHandle = new InputStreamHandle(ID_GEN.getNextId(), Files.newBufferedReader(Paths.get(path))); - return Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle)); + return Terms.actionSuccess(Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle))); } catch (IOException ex) { - throw new RuntimeException(ex); + return Terms.actionError("Error opening input stream: " + ex.getMessage()); } } @SuppressWarnings("unchecked") - public static FunctionTerm inputStreamReadLine(List input) { + public static ActionResultTerm inputStreamReadLine(List input) { if (input.size() != 1) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof InputStreamHandle)) { - throw new IllegalArgumentException("First input term must be an input stream handle!"); + return Terms.actionError("First input term must be an input stream handle!"); } InputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); try { @@ -152,27 +146,26 @@ public static FunctionTerm inputStreamReadLine(List input) { } else { lineTerm = Terms.newConstant(line); } - return Terms.newFunctionTerm("ok", lineTerm); + return Terms.actionSuccess(Terms.newFunctionTerm("line", lineTerm)); } catch (IOException ex) { - throw new RuntimeException(ex); + return Terms.actionError("Error reading data"); } } @SuppressWarnings("unchecked") - public static FunctionTerm inputStreamClose(List input) { + public static ActionResultTerm inputStreamClose(List input) { if (input.size() != 1) { - // TODO do properly - throw new IllegalArgumentException("Incorrect arity!"); + return Terms.actionError("Incorrect input size!"); } if (!(input.get(0) instanceof ConstantTerm) || !(((ConstantTerm) input.get(0)).getObject() instanceof InputStreamHandle)) { - throw new IllegalArgumentException("First input term must be an input stream handle!"); + return Terms.actionError("First input term must be an input stream handle!"); } InputStreamHandle handle = ((ConstantTerm) input.get(0)).getObject(); try { handle.getStream().close(); - return Terms.newFunctionTerm("closeResult", Terms.newSymbolicConstant("ok")); + return Terms.actionSuccess(Terms.newFunctionTerm("closeResult", Terms.newSymbolicConstant("ok"))); } catch (IOException ex) { - throw new RuntimeException(ex); + return Terms.actionError("Error writing data: " + ex.getMessage()); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 2e99a7752..753512151 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -346,7 +346,7 @@ public BasicAtom instantiateActionHead(ActionHead head, Substitution substitutio for (Term inputTerm : actionInput) { substitutedInput.add(inputTerm.substitute(substitution)); } - // Delegate action execution to respctive backend. + // Delegate action execution to respective backend. ActionWitness witness = actionContext.execute(head.getActionName(), ruleId, substitution, substitutedInput); // TODO if the according debug flag is set, convert witness to atom and add to facts. // We have an action result. Add it to the substitution as the substitute for the variable bound to the action so we're able to obtain the diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 5c331c055..7c214243e 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -73,7 +73,7 @@ static SolverFactory newSolverFactory(SystemConfig cfg) { return new SolverFactory(cfg.getSolverName(), cfg.getNogoodStoreName(), solverCfg); } - // TODO lifetime of one ActionContext needs to be exactly runtime ofone program! + // TODO lifetime of one ActionContext needs to be exactly runtime of one program! @VisibleForTesting public static Alpha newAlpha(SystemConfig cfg, ActionContext actionContext) { // Parser factory - Supply correct parser dependent on the accepted input language. From b8821daab7f15d5ac191b9e882c15e01c9f0fd95 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 29 Aug 2022 11:18:59 +0200 Subject: [PATCH 30/96] add debug option to add action witnesses to answer set --- .../kr/alpha/core/actions/ActionWitness.java | 10 ++-- .../transformation/StratifiedEvaluation.java | 48 ++++++++++++++++--- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 4 +- 3 files changed, 49 insertions(+), 13 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java index ffa885726..a81bf4301 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java @@ -8,14 +8,14 @@ public class ActionWitness { private final int ruleId; - private final Substitution groundBody; + private final Substitution groundSubstitution; private final String actionName; private final List actionInput; private final Term actionResult; - public ActionWitness(int ruleId, Substitution groundBody, String actionName, List actionInput, Term actionResult) { + public ActionWitness(int ruleId, Substitution groundSubstitution, String actionName, List actionInput, Term actionResult) { this.ruleId = ruleId; - this.groundBody = groundBody; + this.groundSubstitution = groundSubstitution; this.actionName = actionName; this.actionInput = actionInput; this.actionResult = actionResult; @@ -25,8 +25,8 @@ public int getRuleId() { return ruleId; } - public Substitution getGroundBody() { - return groundBody; + public Substitution getGroundSubstitution() { + return groundSubstitution; } public String getActionName() { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 753512151..cde8a0d87 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -27,10 +27,13 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.rules.heads.InstantiableHead; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.actions.ActionContext; import at.ac.tuwien.kr.alpha.core.actions.ActionWitness; import at.ac.tuwien.kr.alpha.core.depgraph.StratificationAlgorithm; @@ -65,9 +68,11 @@ public class StratifiedEvaluation extends ProgramTransformation(inputProgram.getFacts()); - + // Set up literal instantiator. literalInstantiator = new LiteralInstantiator(new WorkingMemoryBasedInstantiationStrategy(workingMemory)); @@ -317,7 +322,7 @@ private void fireRule(CompiledRule rule, Substitution substitution) { // BasicAtom newAtom = this.instantiate(rule.getHead(), substitution); BasicAtom newAtom; if (rule.getHead() instanceof ActionHead) { - newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution, rule.getRuleId()); + newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution, rule); } else { newAtom = instantiateNormalHead(rule.getHead(), substitution); } @@ -339,7 +344,7 @@ public BasicAtom instantiateNormalHead(NormalHead head, Substitution substitutio } // FIXME should be dispatched via visitor pattern - public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution, int ruleId) { + public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution, CompiledRule rule) { List actionInput = head.getActionInputTerms(); List substitutedInput = new ArrayList<>(); // Substitute all variables in action input so that all input terms are ground. @@ -347,14 +352,45 @@ public BasicAtom instantiateActionHead(ActionHead head, Substitution substitutio substitutedInput.add(inputTerm.substitute(substitution)); } // Delegate action execution to respective backend. - ActionWitness witness = actionContext.execute(head.getActionName(), ruleId, substitution, substitutedInput); - // TODO if the according debug flag is set, convert witness to atom and add to facts. + ActionWitness witness = actionContext.execute(head.getActionName(), rule.getRuleId(), substitution, substitutedInput); + // If the according debug flag is set, convert witness to atom and add to facts. + if (generateActionWitnesses) { + BasicAtom witnessAtom = buildActionWitnessAtom(witness, rule); + // Note that this is a rather "sneaky" side-effect, + // but seems like overkill to do this structurally proper just for a debug feature. + workingMemory.addInstance(witnessAtom, true); + } // We have an action result. Add it to the substitution as the substitute for the variable bound to the action so we're able to obtain the // ground BasicAtom derived by the rule substitution.put(head.getActionOutputTerm(), witness.getActionResult()); return head.getAtom().substitute(substitution); } + private BasicAtom buildActionWitnessAtom(ActionWitness witness, CompiledRule rule) { + // Note that this methods should only ever be used for debugging! + // While action witnesses are used as a semantic concept in the evolog specification, + // they normally only exist implicitly. + + // Construct state term: create function terms from ground body literals. + List functionalizedBody = new ArrayList<>(); + for (Literal lit : rule.getBody()) { + Literal groundLit = lit.substitute(witness.getGroundSubstitution()); + FunctionTerm functionalizedLiteral = Terms.newFunctionTerm(groundLit.getPredicate().getName(), groundLit.getTerms()); + functionalizedBody.add(functionalizedLiteral); + } + FunctionTerm stateTerm = Terms.newFunctionTerm("state", functionalizedBody); + + // Construct input term: wrap action input terms into one function term. + FunctionTerm inputTerm = Terms.newFunctionTerm("input", witness.getActionInput()); + + // Return witness atom: put state and input terms together. + return Atoms.newBasicAtom(Predicates.getPredicate("action_witness", 4), + Terms.newConstant(witness.getActionName()), + stateTerm, + inputTerm, + witness.getActionResult()); + } + private ComponentEvaluationInfo getRulesToEvaluate(ComponentGraph.SCComponent comp) { Set nonRecursiveRules = new HashSet<>(); Set recursiveRules = new HashSet<>(); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 121f642c1..f6ba63352 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -163,7 +163,7 @@ InternalProgram performProgramPreprocessing(NormalProgram program) { AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); // TODO as Evolog moves further along, we want to integrate stratified evaluation with grounder and solver. // Therefore, leave it as is and don't make part of factory API for now. - retVal = new StratifiedEvaluation(actionContext).apply(analyzed); + retVal = new StratifiedEvaluation(actionContext, true).apply(analyzed); } return retVal; } @@ -251,7 +251,7 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; if (enableStratifiedEvaluation) { - preprocessed = new StratifiedEvaluation(actionContext).apply(analyzed).toNormalProgram(); + preprocessed = new StratifiedEvaluation(actionContext, true).apply(analyzed).toNormalProgram(); } else { preprocessed = program; } From dc0198d06c9440b83d6b65d46cd9ee7c4e3ef621 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 29 Aug 2022 16:06:02 +0200 Subject: [PATCH 31/96] specification for action implementation provider --- ...AbstractActionImplementationProvider.java} | 108 ++++++++++++------ ...ntext.java => ActionExecutionService.java} | 2 +- ...l.java => ActionExecutionServiceImpl.java} | 12 +- .../actions/ActionImplementationProvider.java | 30 +++++ .../DefaultActionImplementationProvider.java | 32 ++++++ .../transformation/StratifiedEvaluation.java | 6 +- .../MockActionImplementationProvider.java | 40 +++++++ .../kr/alpha/api/impl/AlphaFactory.java | 10 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 6 +- .../kr/alpha/regressiontests/ActionsTest.java | 10 ++ .../util/RegressionTestUtils.java | 4 + .../alpha.java-common-conventions.gradle.kts | 1 + 12 files changed, 209 insertions(+), 52 deletions(-) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/{Actions.java => AbstractActionImplementationProvider.java} (59%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/{ActionContext.java => ActionExecutionService.java} (87%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/{ActionContextImpl.java => ActionExecutionServiceImpl.java} (86%) create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionImplementationProvider.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/DefaultActionImplementationProvider.java create mode 100644 alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java create mode 100644 alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java similarity index 59% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java index a914f8523..8ec02d340 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/Actions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java @@ -1,15 +1,16 @@ package at.ac.tuwien.kr.alpha.core.actions; -import java.io.FileNotFoundException; -import java.io.FileOutputStream; +import java.io.BufferedReader; import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; import java.io.OutputStream; -import java.nio.file.Files; -import java.nio.file.Paths; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.actions.Action; import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; @@ -17,34 +18,67 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; -public class Actions { +public abstract class AbstractActionImplementationProvider implements ActionImplementationProvider { - public static Map getDefaultActionBindings() { - Map actions = new HashMap<>(); - actions.put("printLine", Actions::printLine); - actions.put("fileOutputStream", Actions::fileOpenOutputStream); - actions.put("streamWrite", Actions::outputStreamWrite); - actions.put("outputStreamClose", Actions::outputStreamClose); + private final IntIdGenerator idGenerator = new IntIdGenerator(); + private final Map supportedActions = new HashMap<>(); - actions.put("fileInputStream", Actions::fileOpenInputStream); - actions.put("streamReadLine", Actions::inputStreamReadLine); - actions.put("inputStreamClose", Actions::inputStreamClose); - return actions; + public AbstractActionImplementationProvider() { + registerAction("fileOutputStream", this::openFileOutputStreamAction); + registerAction("streamWrite", this::outputStreamWriteAction); + registerAction("outputStreamClose", this::outputStreamCloseAction); + registerAction("fileInputStream", this::openFileInputStreamAction); + registerAction("streamReadLine", this::inputStreamReadLineAction); + registerAction("inputStreamClose", this::inputStreamCloseAction); } - // TODO this needs to be encapsulated and made thread-safe! - private static final IntIdGenerator ID_GEN = new IntIdGenerator(); + /** + * Returns a map of all actions supported by this implementation provider. + */ + public final Map getSupportedActions() { + return supportedActions; + } - public static ActionResultTerm> printLine(List input) { - if (input.size() != 1) { - return Terms.actionError("Incorrect input size!"); - } - // TODO this should only work on ConstantTerm - System.out.println(input.get(0).toString()); - return Terms.actionSuccess(Terms.newSymbolicConstant("ok")); + /** + * Returns a predicate interpretation specifying an external that takes no arguments + * and returns a reference to the standard system output stream (stdout). + */ + // TODO we need to reuse this term! (do we?? its interned...) + public final PredicateInterpretation getStdoutTerm() { + return (trms) -> { + if (!trms.isEmpty()) { + throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); + } + return Collections.singleton( + Collections.singletonList( + Terms.newConstant( + new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())))); + }; + } + + /** + * Returns a predicate interpretation specifying an external that takes no arguments + * and returns a reference to the standard system input stream (stdin). + */ + // TODO we need to reuse this term! (do we?? its interned...) + public final PredicateInterpretation getStdinTerm() { + return (trms) -> { + if (!trms.isEmpty()) { + throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); + } + return Collections.singleton( + Collections.singletonList( + Terms.newConstant( + new InputStreamHandle(idGenerator.getNextId(), + new BufferedReader(new InputStreamReader(getStdinStream())))))); + }; + } + + protected final void registerAction(String name, Action action) { + supportedActions.put(name, action); } - public static ActionResultTerm fileOpenOutputStream(List input) { + private ActionResultTerm openFileOutputStreamAction(List input) { if (input.size() != 1) { return Terms.actionError("Incorrect input size!"); } @@ -58,15 +92,15 @@ public static ActionResultTerm fileOpenOutputStream(List input) { } String path = (String) inConst.getObject(); try { - OutputStreamHandle streamHandle = new OutputStreamHandle(ID_GEN.getNextId(), new FileOutputStream(path, true)); + OutputStreamHandle streamHandle = new OutputStreamHandle(idGenerator.getNextId(), getFileOutputStream(path)); return Terms.actionSuccess(Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle))); - } catch (FileNotFoundException e) { + } catch (IOException e) { return Terms.actionError("File not found: " + path); } } @SuppressWarnings("unchecked") - public static ActionResultTerm> outputStreamWrite(List input) { + private ActionResultTerm> outputStreamWriteAction(List input) { if (input.size() != 2) { return Terms.actionError("Incorrect input size!"); } @@ -91,7 +125,7 @@ public static ActionResultTerm> outputStreamWrite(List> outputStreamClose(List input) { + private ActionResultTerm> outputStreamCloseAction(List input) { if (input.size() != 1) { return Terms.actionError("Incorrect input size!"); } @@ -107,7 +141,7 @@ public static ActionResultTerm> outputStreamClose(List fileOpenInputStream(List input) { + private ActionResultTerm openFileInputStreamAction(List input) { if (input.size() != 1) { return Terms.actionError("Incorrect input size!"); } @@ -121,7 +155,7 @@ public static ActionResultTerm fileOpenInputStream(List input) { } String path = (String) inConst.getObject(); try { - InputStreamHandle streamHandle = new InputStreamHandle(ID_GEN.getNextId(), Files.newBufferedReader(Paths.get(path))); + InputStreamHandle streamHandle = new InputStreamHandle(idGenerator.getNextId(), new BufferedReader(new InputStreamReader(getInputStream(path)))); return Terms.actionSuccess(Terms.newFunctionTerm("stream", Terms.newConstant(streamHandle))); } catch (IOException ex) { return Terms.actionError("Error opening input stream: " + ex.getMessage()); @@ -129,7 +163,7 @@ public static ActionResultTerm fileOpenInputStream(List input) { } @SuppressWarnings("unchecked") - public static ActionResultTerm inputStreamReadLine(List input) { + private ActionResultTerm inputStreamReadLineAction(List input) { if (input.size() != 1) { return Terms.actionError("Incorrect input size!"); } @@ -153,7 +187,7 @@ public static ActionResultTerm inputStreamReadLine(List input) { } @SuppressWarnings("unchecked") - public static ActionResultTerm inputStreamClose(List input) { + private ActionResultTerm inputStreamCloseAction(List input) { if (input.size() != 1) { return Terms.actionError("Incorrect input size!"); } @@ -169,4 +203,12 @@ public static ActionResultTerm inputStreamClose(List input) { } } + protected abstract OutputStream getStdoutStream(); + + protected abstract InputStream getStdinStream(); + + protected abstract OutputStream getFileOutputStream(String path) throws IOException; + + protected abstract InputStream getInputStream(String path) throws IOException; + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java similarity index 87% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java index bbcca297e..5e3949519 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContext.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java @@ -5,7 +5,7 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.terms.Term; -public interface ActionContext { +public interface ActionExecutionService { ActionWitness execute(String actionName, int sourceRuleId, Substitution sourceRuleInstance, List inputTerms); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java similarity index 86% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java index 2d570cf38..2952f7f26 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionContextImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java @@ -9,25 +9,23 @@ import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; -public class ActionContextImpl implements ActionContext { +public class ActionExecutionServiceImpl implements ActionExecutionService { - // TODO initialize from outside - private final Map actions; + private final ActionImplementationProvider actionProvider; private final Map actionRecord = new HashMap<>(); - public ActionContextImpl(Map actions) { - this.actions = actions; + public ActionExecutionServiceImpl(ActionImplementationProvider implementationProvider) { + this.actionProvider = implementationProvider; } @Override public ActionWitness execute(String actionName, int sourceRuleId, Substitution sourceRuleInstance, List inputTerms) { - // TODO maybe we want to stuff the whole action head plus substitution in here and do the whole instantiation here? ActionInput actInput = new ActionInput(actionName, sourceRuleId, sourceRuleInstance, inputTerms); return actionRecord.computeIfAbsent(actInput, this::execute); } private ActionWitness execute(ActionInput input) { - Action action = actions.get(input.name); + Action action = actionProvider.getSupportedActions().get(input.name); FunctionTerm result = action.execute(input.inputTerms); return new ActionWitness(input.sourceRule, input.instance, input.name, input.inputTerms, result); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionImplementationProvider.java new file mode 100644 index 000000000..53157b7da --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionImplementationProvider.java @@ -0,0 +1,30 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.util.Map; + +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; + +/** + * Interface for types providing action implementations. + */ +public interface ActionImplementationProvider { + + /** + * Returns a map of all actions supported by this implementation provider. + */ + Map getSupportedActions(); + + /** + * Returns a predicate interpretation specifying an external that takes no arguments + * and returns a reference to the standard system output stream (stdout). + */ + PredicateInterpretation getStdoutTerm(); + + /** + * Returns a predicate interpretation specifying an external that takes no arguments + * and returns a reference to the standard system input stream (stdin). + */ + PredicateInterpretation getStdinTerm(); + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/DefaultActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/DefaultActionImplementationProvider.java new file mode 100644 index 000000000..c6d9a26eb --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/DefaultActionImplementationProvider.java @@ -0,0 +1,32 @@ +package at.ac.tuwien.kr.alpha.core.actions; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.nio.file.StandardOpenOption; + +public class DefaultActionImplementationProvider extends AbstractActionImplementationProvider { + + @Override + protected OutputStream getStdoutStream() { + return System.out; + } + + @Override + protected InputStream getStdinStream() { + return System.in; + } + + @Override + protected OutputStream getFileOutputStream(String path) throws IOException { + return Files.newOutputStream(Paths.get(path), StandardOpenOption.APPEND); + } + + @Override + protected InputStream getInputStream(String path) throws IOException { + return Files.newInputStream(Paths.get(path)); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index cde8a0d87..378a19f65 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -34,7 +34,7 @@ import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.actions.ActionContext; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; import at.ac.tuwien.kr.alpha.core.actions.ActionWitness; import at.ac.tuwien.kr.alpha.core.depgraph.StratificationAlgorithm; import at.ac.tuwien.kr.alpha.core.grounder.IndexedInstanceStorage; @@ -67,10 +67,10 @@ public class StratifiedEvaluation extends ProgramTransformation solvedRuleIds = new HashSet<>(); // Set of rules that have been completely evaluated. private LiteralInstantiator literalInstantiator; - private ActionContext actionContext; + private ActionExecutionService actionContext; private final boolean generateActionWitnesses; - public StratifiedEvaluation(ActionContext actionContext, boolean generateActionWitnesses) { + public StratifiedEvaluation(ActionExecutionService actionContext, boolean generateActionWitnesses) { this.actionContext = actionContext; this.generateActionWitnesses = generateActionWitnesses; } diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java new file mode 100644 index 000000000..388739675 --- /dev/null +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -0,0 +1,40 @@ +package at.ac.tuwien.kr.alpha.test; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import at.ac.tuwien.kr.alpha.core.actions.AbstractActionImplementationProvider; + +public class MockActionImplementationProvider extends AbstractActionImplementationProvider { + + private static final Logger LOGGER = LoggerFactory.getLogger(MockActionImplementationProvider.class); + + @Override + protected OutputStream getStdoutStream() { + // TODO Auto-generated method stub + return null; + } + + @Override + protected InputStream getStdinStream() { + // TODO Auto-generated method stub + return null; + } + + @Override + protected OutputStream getFileOutputStream(String path) throws IOException { + // TODO Auto-generated method stub + return null; + } + + @Override + protected InputStream getInputStream(String path) throws IOException { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 7c214243e..018173818 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -11,9 +11,9 @@ import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.core.actions.ActionContext; -import at.ac.tuwien.kr.alpha.core.actions.ActionContextImpl; -import at.ac.tuwien.kr.alpha.core.actions.Actions; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionServiceImpl; +import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; @@ -75,7 +75,7 @@ static SolverFactory newSolverFactory(SystemConfig cfg) { // TODO lifetime of one ActionContext needs to be exactly runtime of one program! @VisibleForTesting - public static Alpha newAlpha(SystemConfig cfg, ActionContext actionContext) { + public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionContext) { // Parser factory - Supply correct parser dependent on the accepted input language. Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, @@ -93,7 +93,7 @@ public static Alpha newAlpha(SystemConfig cfg, ActionContext actionContext) { } public static Alpha newAlpha(SystemConfig cfg) { - return newAlpha(cfg, new ActionContextImpl(Actions.getDefaultActionBindings())); + return newAlpha(cfg, new ActionExecutionServiceImpl(new DefaultActionImplementationProvider())); } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index f6ba63352..5abf07730 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -59,7 +59,7 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.actions.ActionContext; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; @@ -82,7 +82,7 @@ public class AlphaImpl implements Alpha { private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; - private final ActionContext actionContext; + private final ActionExecutionService actionContext; private final boolean enableStratifiedEvaluation; private final boolean sortAnswerSets; @@ -90,7 +90,7 @@ public class AlphaImpl implements Alpha { AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, GrounderFactory grounderFactory, SolverFactory solverFactory, - ActionContext actionContext, + ActionExecutionService actionContext, boolean enableStratifiedEvaluation, boolean sortAnswerSets) { this.parserFactory = parserFactory; this.programNormalizationFactory = programNormalizationFactory; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java new file mode 100644 index 000000000..f27ac93fc --- /dev/null +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java @@ -0,0 +1,10 @@ +package at.ac.tuwien.kr.alpha.regressiontests; + +/** + * End-to-end tests covering Evolog action support. + * Note that all tests in this suite depend on stratified evaluation being enabled. + */ +public class ActionsTest { + + +} diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java index 82f2b88df..4e7f4e831 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java @@ -80,4 +80,8 @@ public static void ignoreTestForNonDefaultDomainIndependentHeuristics(SystemConf Assumptions.assumeTrue(cfg.getBranchingHeuristic() == Heuristic.VSIDS); } + public static void ignoreTestForStratifiedEvaluationDisabled(SystemConfig cfg) { + Assumptions.assumeTrue(cfg.isEvaluateStratifiedPart()); + } + } diff --git a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts index deace0036..1ccb2d408 100644 --- a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts @@ -37,6 +37,7 @@ dependencies { testImplementation("org.slf4j:slf4j-simple:1.7.32") testFixturesApi(jupiter("api")) + testFixturesApi("org.slf4j:slf4j-api:1.7.32") } // JUnit 5 From e80c424b3412cd2561d123f829e6c66cc9423efa Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 29 Aug 2022 16:39:41 +0200 Subject: [PATCH 32/96] mock action provider for testing --- .../MockActionImplementationProvider.java | 50 ++++++++++++++++--- 1 file changed, 42 insertions(+), 8 deletions(-) diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java index 388739675..778107c50 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -1,8 +1,11 @@ package at.ac.tuwien.kr.alpha.test; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -11,30 +14,61 @@ public class MockActionImplementationProvider extends AbstractActionImplementationProvider { + @SuppressWarnings("unused") private static final Logger LOGGER = LoggerFactory.getLogger(MockActionImplementationProvider.class); + private ByteArrayOutputStream stdoutMock = new ByteArrayOutputStream(); + private ByteArrayInputStream stdinMock; + private Map mockedFileOutputs; + private Map mockedFileInputs; + + public MockActionImplementationProvider() { + } + @Override protected OutputStream getStdoutStream() { - // TODO Auto-generated method stub - return null; + return stdoutMock; + } + + public String getStdoutContent() { + return stdoutMock.toString(); + } + + public void resetStdoutContent() { + stdoutMock.reset(); + } + + public void setMockInput(String input) { + stdinMock = new ByteArrayInputStream(input.getBytes()); + } + + public void setMockedFileOutputs(Map mockedFileOutputs) { + this.mockedFileOutputs = mockedFileOutputs; + } + + public void setMockedFileInputs(Map mockedFileInputs) { + this.mockedFileInputs = mockedFileInputs; } @Override protected InputStream getStdinStream() { - // TODO Auto-generated method stub - return null; + return stdinMock; } @Override protected OutputStream getFileOutputStream(String path) throws IOException { - // TODO Auto-generated method stub - return null; + if(mockedFileOutputs.containsKey(path)) { + return mockedFileOutputs.get(path); + } + throw new IOException("Path does not exist!"); } @Override protected InputStream getInputStream(String path) throws IOException { - // TODO Auto-generated method stub - return null; + if(mockedFileInputs.containsKey(path)) { + return mockedFileInputs.get(path); + } + throw new IOException("Path does not exist!"); } } From 399ec00a93b7143f884ee2fde59830690d0c1349 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 1 Sep 2022 18:32:15 +0200 Subject: [PATCH 33/96] mock implementation provider and smoke test for actions --- .../AbstractActionImplementationProvider.java | 17 ++-- .../MockActionImplementationProvider.java | 6 +- .../kr/alpha/api/impl/AlphaFactory.java | 8 +- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 82 +++++++------------ .../kr/alpha/regressiontests/ActionsTest.java | 10 --- 5 files changed, 47 insertions(+), 76 deletions(-) delete mode 100644 alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java index 8ec02d340..cda9a2eea 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java @@ -23,6 +23,12 @@ public abstract class AbstractActionImplementationProvider implements ActionImpl private final IntIdGenerator idGenerator = new IntIdGenerator(); private final Map supportedActions = new HashMap<>(); + private final ConstantTerm stdout = Terms.newConstant( + new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())); + private final ConstantTerm stdin = Terms.newConstant( + new InputStreamHandle(idGenerator.getNextId(), + new BufferedReader(new InputStreamReader(getStdinStream())))); + public AbstractActionImplementationProvider() { registerAction("fileOutputStream", this::openFileOutputStreamAction); registerAction("streamWrite", this::outputStreamWriteAction); @@ -49,10 +55,7 @@ public final PredicateInterpretation getStdoutTerm() { if (!trms.isEmpty()) { throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); } - return Collections.singleton( - Collections.singletonList( - Terms.newConstant( - new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())))); + return Collections.singleton(Collections.singletonList(stdout)); }; } @@ -66,11 +69,7 @@ public final PredicateInterpretation getStdinTerm() { if (!trms.isEmpty()) { throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); } - return Collections.singleton( - Collections.singletonList( - Terms.newConstant( - new InputStreamHandle(idGenerator.getNextId(), - new BufferedReader(new InputStreamReader(getStdinStream())))))); + return Collections.singleton(Collections.singletonList(stdin)); }; } diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java index 778107c50..a31173162 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -57,7 +57,7 @@ protected InputStream getStdinStream() { @Override protected OutputStream getFileOutputStream(String path) throws IOException { - if(mockedFileOutputs.containsKey(path)) { + if (mockedFileOutputs.containsKey(path)) { return mockedFileOutputs.get(path); } throw new IOException("Path does not exist!"); @@ -65,10 +65,10 @@ protected OutputStream getFileOutputStream(String path) throws IOException { @Override protected InputStream getInputStream(String path) throws IOException { - if(mockedFileInputs.containsKey(path)) { + if (mockedFileInputs.containsKey(path)) { return mockedFileInputs.get(path); } throw new IOException("Path does not exist!"); } - + } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 018173818..76ed54955 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -76,8 +76,12 @@ static SolverFactory newSolverFactory(SystemConfig cfg) { // TODO lifetime of one ActionContext needs to be exactly runtime of one program! @VisibleForTesting public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionContext) { + // Parser factory - Supply correct parser dependent on the accepted input language. Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); + if (cfg.isAcceptEvologPrograms()) { + + } Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, cfg.getAggregateRewritingConfig()); @@ -86,17 +90,17 @@ public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionCont // SolverFactory - Same as for GrounderFactory, we need a new Solver for each program. SolverFactory solverFactory = newSolverFactory(cfg); - + // Now that all dependencies are taken care of, build new Alpha instance. return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, actionContext, cfg.isEvaluateStratifiedPart(), cfg.isSortAnswerSets()); } + // TODO action stuff should go into system config public static Alpha newAlpha(SystemConfig cfg) { return newAlpha(cfg, new ActionExecutionServiceImpl(new DefaultActionImplementationProvider())); } - // Create Alpha instance with default config. public static Alpha newAlpha() { return newAlpha(new SystemConfig()); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index f4e2a31c4..0b61309b1 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,59 +1,37 @@ package at.ac.tuwien.kr.alpha; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.apache.commons.lang3.StringUtils; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; - +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionServiceImpl; +import at.ac.tuwien.kr.alpha.test.MockActionImplementationProvider; + +/** + * End-to-end tests covering Evolog action support. + * Note that all tests in this suite depend on stratified evaluation being enabled. + */ public class ActionsTest { - private static class MockActionBindings { - - static final Logger LOGGER = LoggerFactory.getLogger(MockActionBindings.class); - - Map, Integer> fileOpenOutputStreamInvocations = new HashMap<>(); - Map, Integer> outputStreamWriteInvocations = new HashMap<>(); - Map, Integer> outputStreamCloseInvocations = new HashMap<>(); - Map, Integer> fileOpenInputStreamInvocations = new HashMap<>(); - Map, Integer> inputStreamReadLineInvocations = new HashMap<>(); - Map, Integer> inputStreamCloseInvocations = new HashMap<>(); - - public FunctionTerm fileOpenOutputStream(List input) { - if (fileOpenOutputStreamInvocations.containsKey(input)) { - fileOpenOutputStreamInvocations.put(input, fileOpenOutputStreamInvocations.get(input) + 1); - } else { - fileOpenOutputStreamInvocations.put(input, 1); - } - LOGGER.info("Action fileOpenOutputStream({})", StringUtils.join(input, ", ")); - return null; - } - - public FunctionTerm outputStreamWrite(List input) { - return null; - } - - public FunctionTerm outputStreamClose(List input) { - return null; - } - - public FunctionTerm fileOpenInputStream(List input) { - return null; - } - - public FunctionTerm inputStreamReadLine(List input) { - return null; - } - - public FunctionTerm inputStreamClose(List inputStream) { - return null; - } - + private static final String HELLO_WORLD = + "hello_result(RES) : @streamWrite[STDOUT, \" World!\"] = RES :- &stdout(STDOUT)."; + + /** + * Simple smoke test which verifies correct behavior of an Evolog "Hello World" program. + */ + @Test + @Disabled // TODO we need to pass stdin/stdout externals into parser + public void helloWorld() { + MockActionImplementationProvider actionMock = new MockActionImplementationProvider(); + ActionExecutionService actionService = new ActionExecutionServiceImpl(actionMock); + Alpha alpha = AlphaFactory.newAlpha(new SystemConfig(), actionService); + InputProgram program = alpha.readProgramString(HELLO_WORLD); + alpha.solve(program); + // TODO check mock for correct output content } } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java deleted file mode 100644 index f27ac93fc..000000000 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ActionsTest.java +++ /dev/null @@ -1,10 +0,0 @@ -package at.ac.tuwien.kr.alpha.regressiontests; - -/** - * End-to-end tests covering Evolog action support. - * Note that all tests in this suite depend on stratified evaluation being enabled. - */ -public class ActionsTest { - - -} From 20c2b7305abb21773becd19e50fb9a70efa206a0 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sat, 3 Sep 2022 17:17:21 +0200 Subject: [PATCH 34/96] remove option to switch off stratified evaluation --- .../kr/alpha/api/config/SystemConfig.java | 10 --------- .../kr/alpha/api/impl/AlphaFactory.java | 4 ++-- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 21 +++++-------------- 3 files changed, 7 insertions(+), 28 deletions(-) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java index ec129fbc4..25c79b348 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java @@ -56,7 +56,6 @@ public class SystemConfig { public static final boolean DEFAULT_DEBUG_INTERNAL_CHECKS = false; public static final boolean DEFAULT_SORT_ANSWER_SETS = false; public static final List DEFAULT_REPLAY_CHOICES = Collections.emptyList(); - public static final boolean DEFAULT_STRATIFIED_EVALUATION = true; public static final boolean DEFAULT_DISABLE_NOGOOD_DELETION = false; public static final String DEFAULT_GROUNDER_TOLERANCE_CONSTRAINTS = GrounderHeuristicsConfiguration.STRICT_STRING; public static final String DEFAULT_GROUNDER_TOLERANCE_RULES = GrounderHeuristicsConfiguration.STRICT_STRING; @@ -76,7 +75,6 @@ public class SystemConfig { private boolean disableJustificationSearch = DEFAULT_DISABLE_JUSTIFICATION_SEARCH; private boolean sortAnswerSets = DEFAULT_SORT_ANSWER_SETS; private List replayChoices = DEFAULT_REPLAY_CHOICES; - private boolean evaluateStratifiedPart = DEFAULT_STRATIFIED_EVALUATION; private boolean disableNoGoodDeletion = DEFAULT_DISABLE_NOGOOD_DELETION; private String grounderToleranceConstraints = DEFAULT_GROUNDER_TOLERANCE_CONSTRAINTS; private String grounderToleranceRules = DEFAULT_GROUNDER_TOLERANCE_RULES; @@ -199,14 +197,6 @@ public void setReplayChoices(String replayChoices) { this.replayChoices = Arrays.stream(replayChoices.split(",")).map(String::trim).map(Integer::valueOf).collect(Collectors.toList()); } - public boolean isEvaluateStratifiedPart() { - return this.evaluateStratifiedPart; - } - - public void setEvaluateStratifiedPart(boolean evaluateStratifiedPart) { - this.evaluateStratifiedPart = evaluateStratifiedPart; - } - public boolean isDisableNoGoodDeletion() { return this.disableNoGoodDeletion; } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 76ed54955..56d35fe87 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -79,9 +79,9 @@ public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionCont // Parser factory - Supply correct parser dependent on the accepted input language. Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); - if (cfg.isAcceptEvologPrograms()) { + // if (cfg.isAcceptEvologPrograms()) { - } + // } Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, cfg.getAggregateRewritingConfig()); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 5abf07730..1d3683fda 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -82,22 +82,17 @@ public class AlphaImpl implements Alpha { private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; - private final ActionExecutionService actionContext; - private final boolean enableStratifiedEvaluation; private final boolean sortAnswerSets; AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, GrounderFactory grounderFactory, SolverFactory solverFactory, - ActionExecutionService actionContext, boolean enableStratifiedEvaluation, boolean sortAnswerSets) { this.parserFactory = parserFactory; this.programNormalizationFactory = programNormalizationFactory; this.grounderFactory = grounderFactory; this.solverFactory = solverFactory; - this.actionContext = actionContext; - this.enableStratifiedEvaluation = enableStratifiedEvaluation; this.sortAnswerSets = sortAnswerSets; } @@ -159,12 +154,9 @@ public NormalProgram normalizeProgram(InputProgram program) { InternalProgram performProgramPreprocessing(NormalProgram program) { LOGGER.debug("Preprocessing InternalProgram!"); InternalProgram retVal = InternalProgram.fromNormalProgram(program); - if (enableStratifiedEvaluation) { - AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); - // TODO as Evolog moves further along, we want to integrate stratified evaluation with grounder and solver. - // Therefore, leave it as is and don't make part of factory API for now. - retVal = new StratifiedEvaluation(actionContext, true).apply(analyzed); - } + // TODO get the StratifiedEvaluation from factory + AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); + retVal = new StratifiedEvaluation(actionContext, true).apply(analyzed); return retVal; } @@ -250,11 +242,8 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final ComponentGraph compGraph; final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; - if (enableStratifiedEvaluation) { - preprocessed = new StratifiedEvaluation(actionContext, true).apply(analyzed).toNormalProgram(); - } else { - preprocessed = program; - } + // TODO get the StratifiedEvaluation from factory + preprocessed = new StratifiedEvaluation(actionContext, true).apply(analyzed).toNormalProgram(); depGraph = analyzed.getDependencyGraph(); compGraph = analyzed.getComponentGraph(); final Solver solver = prepareSolverFor(analyzed, filter); From 6b2bba25f4a5e7bfbf65915a09df5350fe785181 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sat, 3 Sep 2022 17:59:51 +0200 Subject: [PATCH 35/96] ensure statelessness of program transformations, reflect this in naming --- ...ng.java => ArithmeticTermTransformer.java} | 18 ++++++--- ...oNormal.java => ChoiceHeadNormalizer.java} | 4 +- ...iting.java => EnumerationTransformer.java} | 4 +- ...Atom.java => IntervalTermTransformer.java} | 5 ++- .../NormalizeProgramTransformation.java | 40 +++++++++++-------- ...formation.java => ProgramTransformer.java} | 4 +- .../transformation/StratifiedEvaluation.java | 4 +- ....java => VariableEqualityTransformer.java} | 4 +- ...writing.java => AggregateTransformer.java} | 10 ++--- .../StringtemplateBasedAggregateEncoder.java | 4 +- .../ProgramTransformationTest.java | 8 ++-- .../kr/alpha/api/impl/AlphaFactory.java | 10 ++--- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 12 +++--- .../alpha/ArithmeticTermsRewritingTest.java | 10 ++--- 14 files changed, 76 insertions(+), 61 deletions(-) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ArithmeticTermsRewriting.java => ArithmeticTermTransformer.java} (91%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ChoiceHeadToNormal.java => ChoiceHeadNormalizer.java} (97%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{EnumerationRewriting.java => EnumerationTransformer.java} (96%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{IntervalTermToIntervalAtom.java => IntervalTermTransformer.java} (98%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ProgramTransformation.java => ProgramTransformer.java} (56%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{VariableEqualityRemoval.java => VariableEqualityTransformer.java} (97%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/{AggregateRewriting.java => AggregateTransformer.java} (95%) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java similarity index 91% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java index 1a346527c..0dc7e5dd7 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java @@ -23,6 +23,7 @@ import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; @@ -33,12 +34,16 @@ * * Copyright (c) 2020-2021, the Alpha Team. */ -public class ArithmeticTermsRewriting extends ProgramTransformation { - private static final String ARITHMETIC_VARIABLES_PREFIX = "_A"; - private int numArithmeticVariables; +public class ArithmeticTermTransformer extends ProgramTransformer { + + /** + * The prefix with which to begin names of internal variables created by this transformer. + */ + private final String generatedVariablesPrefix = "_A"; + private final IntIdGenerator variableNumberGenerator = new IntIdGenerator(); @Override - public NormalProgram apply(NormalProgram inputProgram) { + public NormalProgram transform(NormalProgram inputProgram) { List rewrittenRules = new ArrayList<>(); boolean didRewrite = false; for (NormalRule inputProgramRule : inputProgram.getRules()) { @@ -64,7 +69,7 @@ public NormalProgram apply(NormalProgram inputProgram) { * @return the rewritten rule. Note that a new {@link NormalRule} is returned for every call of this method. */ private NormalRule rewriteRule(NormalRule inputProgramRule) { - numArithmeticVariables = 0; // Reset number of introduced variables for each rule. + variableNumberGenerator.resetGenerator(); // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; Set rewrittenBodyLiterals = new LinkedHashSet<>(); // Rewrite head. @@ -118,7 +123,7 @@ private Term rewriteArithmeticSubterms(Term term, Set bodyLiterals) { } // Switch on term type. if (term instanceof ArithmeticTerm) { - VariableTerm replacementVariable = Terms.newVariable(ARITHMETIC_VARIABLES_PREFIX + numArithmeticVariables++); + VariableTerm replacementVariable = Terms.newVariable(generatedVariablesPrefix + variableNumberGenerator.getNextId()); bodyLiterals.add(Atoms.newComparisonAtom(replacementVariable, term, ComparisonOperators.EQ).toLiteral()); return replacementVariable; } else if (term instanceof VariableTerm || term instanceof ConstantTerm) { @@ -179,4 +184,5 @@ private boolean containsArithmeticTerm(Term term) { throw Util.oops("Unexpected term type: " + term.getClass()); } } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java similarity index 97% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java index 7a59afd45..c90cc32cf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java @@ -55,11 +55,11 @@ * Copyright (c) 2017-2021, the Alpha Team. */ // TODO this could already give NormalProgram as result type -public class ChoiceHeadToNormal extends ProgramTransformation { +public class ChoiceHeadNormalizer extends ProgramTransformer { private final static String PREDICATE_NEGATION_PREFIX = "_n"; @Override - public InputProgram apply(InputProgram inputProgram) { + public InputProgram transform(InputProgram inputProgram) { InputProgramImpl.Builder programBuilder = InputProgramImpl.builder(); List> additionalRules = new ArrayList<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java similarity index 96% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java index 8c9e67f1e..14bd3109a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java @@ -32,10 +32,10 @@ * Copyright (c) 2017-2020, the Alpha Team. */ // TODO this should happen during/after internalization -public class EnumerationRewriting extends ProgramTransformation { +public class EnumerationTransformer extends ProgramTransformer { @Override - public InputProgram apply(InputProgram inputProgram) { + public InputProgram transform(InputProgram inputProgram) { // Read enumeration predicate from directive. String enumDirective = inputProgram.getInlineDirectives().getDirectiveValue(InlineDirectivesImpl.DIRECTIVE.enum_predicate_is); if (enumDirective == null) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java similarity index 98% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java index e5b0f9abe..6b1f3f14c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java @@ -58,7 +58,8 @@ * * Copyright (c) 2017-2021, the Alpha Team. */ -public class IntervalTermToIntervalAtom extends ProgramTransformation { +public class IntervalTermTransformer extends ProgramTransformer { + private static final String INTERVAL_VARIABLE_PREFIX = "_Interval"; /** @@ -169,7 +170,7 @@ private static FunctionTerm rewriteFunctionTerm(FunctionTerm functionTerm, Map rewrittenRules = new ArrayList<>(); for (NormalRule rule : inputProgram.getRules()) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java index 341c46eb1..1d075903e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java @@ -1,45 +1,53 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.function.Supplier; - import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateTransformer; /** * Encapsulates all transformations necessary to transform a given program into a @{link NormalProgram} that is understood by Alpha internally * * Copyright (c) 2019-2021, the Alpha Team. */ -public class NormalizeProgramTransformation extends ProgramTransformation { - - private final Supplier aggregateRewritingFactory; - - public NormalizeProgramTransformation(Supplier aggregateRewritingFactory) { - this.aggregateRewritingFactory = aggregateRewritingFactory; +public class NormalizeProgramTransformation extends ProgramTransformer { + + private final VariableEqualityTransformer equalityTransformer; + private final ChoiceHeadNormalizer choiceHeadNormalizer; + private final AggregateTransformer aggregateTransformer; + private final EnumerationTransformer enumerationTransformer; + private final IntervalTermTransformer intervalTermTransformer; + private final ArithmeticTermTransformer arithmeticTermTransformer; + + public NormalizeProgramTransformation(VariableEqualityTransformer equalityTransformer, ChoiceHeadNormalizer choiceHeadNormalizer, AggregateTransformer aggregateTransformer, EnumerationTransformer enumerationTransformer, IntervalTermTransformer intervalTermTransformer, ArithmeticTermTransformer arithmeticTermTransformer) { + this.equalityTransformer = equalityTransformer; + this.choiceHeadNormalizer = choiceHeadNormalizer; + this.aggregateTransformer = aggregateTransformer; + this.enumerationTransformer = enumerationTransformer; + this.intervalTermTransformer = intervalTermTransformer; + this.arithmeticTermTransformer = arithmeticTermTransformer; } @Override - public NormalProgram apply(InputProgram inputProgram) { + public NormalProgram transform(InputProgram inputProgram) { InputProgram tmpPrg; // Remove variable equalities. - tmpPrg = new VariableEqualityRemoval().apply(inputProgram); + tmpPrg = equalityTransformer.transform(inputProgram); // Transform choice rules. - tmpPrg = new ChoiceHeadToNormal().apply(tmpPrg); + tmpPrg = choiceHeadNormalizer.transform(tmpPrg); // Transform aggregates. - tmpPrg = aggregateRewritingFactory.get().apply(tmpPrg); + tmpPrg = aggregateTransformer.transform(tmpPrg); // Transform enumeration atoms. - tmpPrg = new EnumerationRewriting().apply(tmpPrg); + tmpPrg = enumerationTransformer.transform(tmpPrg); EnumerationAtom.resetEnumerations(); // Construct the normal program. NormalProgram retVal = NormalProgramImpl.fromInputProgram(tmpPrg); // Transform intervals. - retVal = new IntervalTermToIntervalAtom().apply(retVal); + retVal = intervalTermTransformer.transform(retVal); // Rewrite ArithmeticTerms. - retVal = new ArithmeticTermsRewriting().apply(retVal); + retVal = arithmeticTermTransformer.transform(retVal); return retVal; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java similarity index 56% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java index 0b7d4e7f1..dad7f48d9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java @@ -6,8 +6,8 @@ /** * Copyright (c) 2017-2019, the Alpha Team. */ -public abstract class ProgramTransformation>, O extends Program>> { +public abstract class ProgramTransformer>, O extends Program>> { - public abstract O apply(I inputProgram); + public abstract O transform(I inputProgram); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 378a19f65..9e4859e7f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -54,7 +54,7 @@ * * Copyright (c) 2019-2020, the Alpha Team. */ -public class StratifiedEvaluation extends ProgramTransformation implements RuleInstantiator { +public class StratifiedEvaluation extends ProgramTransformer implements RuleInstantiator { private static final Logger LOGGER = LoggerFactory.getLogger(StratifiedEvaluation.class); @@ -78,7 +78,7 @@ public StratifiedEvaluation(ActionExecutionService actionContext, boolean genera @Override // Note: ideally this returns a "PartiallyEvaluatedProgram" such that the grounder can directly use the working // memories created here rather than re-initialize everything. - public InternalProgram apply(AnalyzedProgram inputProgram) { + public InternalProgram transform(AnalyzedProgram inputProgram) { // Calculate a stratification and initialize the working memory. ComponentGraph componentGraph = inputProgram.getComponentGraph(); List strata = StratificationAlgorithm.calculateStratification(componentGraph); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java similarity index 97% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java index 9ccad4d9f..a9bb46a1e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java @@ -59,10 +59,10 @@ * * Copyright (c) 2017-2021, the Alpha Team. */ -public class VariableEqualityRemoval extends ProgramTransformation { +public class VariableEqualityTransformer extends ProgramTransformer { @Override - public InputProgram apply(InputProgram inputProgram) { + public InputProgram transform(InputProgram inputProgram) { List> rewrittenRules = new ArrayList<>(); for (Rule rule : inputProgram.getRules()) { rewrittenRules.add(findAndReplaceVariableEquality(rule)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java similarity index 95% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java index bd8761d08..b277a635a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java @@ -19,7 +19,7 @@ import at.ac.tuwien.kr.alpha.commons.literals.Literals; import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AbstractAggregateEncoder; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.CountEncoder; @@ -31,7 +31,7 @@ * * Copyright (c) 2020, the Alpha Team. */ -public class AggregateRewriting extends ProgramTransformation { +public class AggregateTransformer extends ProgramTransformer { private final AbstractAggregateEncoder countEqualsEncoder; private final AbstractAggregateEncoder countLessOrEqualEncoder; @@ -41,7 +41,7 @@ public class AggregateRewriting extends ProgramTransformation> outputRules = new ArrayList<>(); for (Rule inputRule : inputProgram.getRules()) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index 5c1bbde5b..a86a660d1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -20,7 +20,7 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; -import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationRewriting; +import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationTransformer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; /** @@ -81,7 +81,7 @@ protected InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode) { String coreEncodingAsp = coreEncodingTemplate.render(); // Create the basic program - InputProgram coreEncoding = new EnumerationRewriting().apply(parser.parse(coreEncodingAsp)); + InputProgram coreEncoding = new EnumerationTransformer().transform(parser.parse(coreEncodingAsp)); // Add the programatically created bound rule and return return new InputProgramImpl(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index f56f48ccf..1e2566d52 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -29,8 +29,8 @@ public class ProgramTransformationTest { // TODO should this always be an evolog parser? private static final ProgramParser PARSER = new EvologProgramParser(); - private ChoiceHeadToNormal choiceToNormal = new ChoiceHeadToNormal(); - private IntervalTermToIntervalAtom intervalRewriting = new IntervalTermToIntervalAtom(); + private ChoiceHeadNormalizer choiceToNormal = new ChoiceHeadNormalizer(); + private IntervalTermTransformer intervalRewriting = new IntervalTermTransformer(); @SuppressWarnings("resource") private static String readTestResource(String resource) throws IOException { @@ -45,7 +45,7 @@ private static String readTestResource(String resource) throws IOException { return bld.toString(); } - private , O extends Program> void genericTransformationTest(ProgramTransformation transform, + private , O extends Program> void genericTransformationTest(ProgramTransformer transform, Function prepareFunc, String resourceSet) { try { String inputCode = ProgramTransformationTest.readTestResource(resourceSet + ".in"); @@ -53,7 +53,7 @@ private , O extends Program> void genericTransformationT InputProgram inputProg = PARSER.parse(inputCode, Externals.scan(ProgramTransformationTest.class)); I transformInput = prepareFunc.apply(inputProg); String beforeTransformProg = transformInput.toString(); - O transformedProg = transform.apply(transformInput); + O transformedProg = transform.transform(transformInput); assertEquals(expectedResult, transformedProg.toString(), "Transformation result doesn't match expected result"); assertEquals(beforeTransformProg, transformInput.toString(), "Transformation modified source program (breaks immutability!)"); } catch (Exception ex) { diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 56d35fe87..aeb0fed9e 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -18,8 +18,8 @@ import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateTransformer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AggregateEncoderFactory; import at.ac.tuwien.kr.alpha.core.solver.SolverConfig; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; @@ -31,7 +31,7 @@ private AlphaFactory() { throw new AssertionError("Cannot instantiate utility class!"); } - static Supplier> newProgramNormalizationFactory(Supplier parserFactory, + static Supplier> newProgramNormalizationFactory(Supplier parserFactory, AggregateRewritingConfig aggregateCfg) { // AggregateEncoderFactory depends on parser factory since stringtemplate-based aggregate encoders need to use the same parser that's used // for input programs. @@ -39,7 +39,7 @@ static Supplier> newProgramNo aggregateCfg.isUseSortingGridEncoding(), aggregateCfg.isSupportNegativeValuesInSums()); // Factory for aggregate rewriting (depends on encoders provided by above factory). - Supplier aggregateRewritingFactory = () -> new AggregateRewriting(aggregateEncoderFactory.newCountEqualsEncoder(), + Supplier aggregateRewritingFactory = () -> new AggregateTransformer(aggregateEncoderFactory.newCountEqualsEncoder(), aggregateEncoderFactory.newCountLessOrEqualEncoder(), aggregateEncoderFactory.newSumEqualsEncoder(), aggregateEncoderFactory.newSumLessOrEqualEncoder(), aggregateEncoderFactory.newMinEncoder(), aggregateEncoderFactory.newMaxEncoder()); @@ -82,7 +82,7 @@ public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionCont // if (cfg.isAcceptEvologPrograms()) { // } - Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, + Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, cfg.getAggregateRewritingConfig()); // GrounderFactory - Since every grounder instance is only good for one program instance, we need a factory. diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 1d3683fda..5bb5d1621 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -68,7 +68,7 @@ import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformer; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; @@ -77,7 +77,7 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); private final Supplier parserFactory; - private final Supplier> programNormalizationFactory; + private final Supplier> programNormalizationFactory; private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; @@ -85,7 +85,7 @@ public class AlphaImpl implements Alpha { private final boolean sortAnswerSets; - AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, + AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, GrounderFactory grounderFactory, SolverFactory solverFactory, boolean enableStratifiedEvaluation, boolean sortAnswerSets) { @@ -147,7 +147,7 @@ public InputProgram readProgramString(String aspString) { @Override public NormalProgram normalizeProgram(InputProgram program) { - return programNormalizationFactory.get().apply(program); + return programNormalizationFactory.get().transform(program); } @VisibleForTesting @@ -156,7 +156,7 @@ InternalProgram performProgramPreprocessing(NormalProgram program) { InternalProgram retVal = InternalProgram.fromNormalProgram(program); // TODO get the StratifiedEvaluation from factory AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); - retVal = new StratifiedEvaluation(actionContext, true).apply(analyzed); + retVal = new StratifiedEvaluation(actionContext, true).transform(analyzed); return retVal; } @@ -243,7 +243,7 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; // TODO get the StratifiedEvaluation from factory - preprocessed = new StratifiedEvaluation(actionContext, true).apply(analyzed).toNormalProgram(); + preprocessed = new StratifiedEvaluation(actionContext, true).transform(analyzed).toNormalProgram(); depGraph = analyzed.getDependencyGraph(); compGraph = analyzed.getComponentGraph(); final Solver solver = prepareSolverFor(analyzed, filter); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index d642e2cf8..637fe75a1 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -25,7 +25,7 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermTransformer; /** * Copyright (c) 2021, the Alpha Team. @@ -47,8 +47,8 @@ public static Set>> externalForArithmeticTermsRewriti public void rewriteRule() { NormalProgram inputProgram = NormalProgramImpl.fromInputProgram(parser.parse("p(X+1) :- q(Y/2), r(f(X*2),Y), X-2 = Y*3, X = 0..9.")); assertEquals(1, inputProgram.getRules().size()); - ArithmeticTermsRewriting arithmeticTermsRewriting = new ArithmeticTermsRewriting(); - NormalProgram rewrittenProgram = arithmeticTermsRewriting.apply(inputProgram); + ArithmeticTermTransformer arithmeticTermsRewriting = new ArithmeticTermTransformer(); + NormalProgram rewrittenProgram = arithmeticTermsRewriting.transform(inputProgram); // Expect the rewritten program to be one rule with: p(_A0) :- _A0 = X+1, _A1 = Y/2, q(_A1), _A2 = X*2, r(f(_A2),Y), X-2 = Y*3, X = 0..9. assertEquals(1, rewrittenProgram.getRules().size()); NormalRule rewrittenRule = rewrittenProgram.getRules().get(0); @@ -60,8 +60,8 @@ public void rewriteRule() { public void rewriteExternalAtom() { NormalProgram inputProgram = NormalProgramImpl.fromInputProgram(parser.parse("p :- Y = 13, &extArithTest[Y*5](Y-4).")); assertEquals(1, inputProgram.getRules().size()); - ArithmeticTermsRewriting arithmeticTermsRewriting = new ArithmeticTermsRewriting(); - NormalProgram rewrittenProgram = arithmeticTermsRewriting.apply(inputProgram); + ArithmeticTermTransformer arithmeticTermsRewriting = new ArithmeticTermTransformer(); + NormalProgram rewrittenProgram = arithmeticTermsRewriting.transform(inputProgram); assertEquals(1, rewrittenProgram.getRules().size()); NormalRule rewrittenRule = rewrittenProgram.getRules().get(0); assertEquals(4, rewrittenRule.getBody().size()); From 7802ffb1e321d3cea9ecfcfa5f61994b08a86913 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 5 Sep 2022 14:50:38 +0200 Subject: [PATCH 36/96] incorporate action support into AlphaFactory, remove option to disable StratifiedEvaluation --- .../java/at/ac/tuwien/kr/alpha/api/Alpha.java | 33 +++- .../main/java/at/ac/tuwien/kr/alpha/Main.java | 2 +- .../alpha/app/config/CommandLineParser.java | 9 -- .../alpha/app/ComponentGraphWriterTest.java | 2 +- .../alpha/app/DependencyGraphWriterTest.java | 2 +- .../app/config/CommandLineParserTest.java | 15 -- .../AnswerSetToWorkbookMapperTest.java | 2 +- .../core/parser/AbstractProgramParser.java | 4 + .../parser/evolog/EvologProgramParser.java | 10 +- .../kr/alpha/core/programs/Programs.java | 26 --- ...sformation.java => ProgramNormalizer.java} | 4 +- .../transformation/StratifiedEvaluation.java | 8 +- .../encoders/AggregateEncoderFactory.java | 44 ----- .../encoders/AggregateEncoders.java | 36 +++++ .../aggregates/encoders/MinMaxEncoder.java | 2 +- .../aggregates/encoders/SumEncoder.java | 4 +- .../alpha/core/parser/EvologParserTest.java | 3 +- .../ProgramTransformationTest.java | 6 +- .../kr/alpha/api/impl/AlphaFactory.java | 91 ++++++----- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 42 +++-- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 2 +- .../alpha/AggregateRewritingContextTest.java | 4 +- .../kr/alpha/AggregateRewritingTest.java | 2 +- .../alpha/ArithmeticTermsRewritingTest.java | 4 +- .../FixedInterpretationLiteralsTest.java | 2 +- .../at/ac/tuwien/kr/alpha/RuleParser.java | 4 +- .../ac/tuwien/kr/alpha/RuleToStringTest.java | 4 +- .../kr/alpha/StratifiedEvaluationTest.java | 26 +-- .../kr/alpha/api/impl/AlphaImplTest.java | 151 ++++++------------ .../HeadBodyTransformationTests.java | 4 +- .../regressiontests/OmigaBenchmarksTest.java | 4 +- .../kr/alpha/regressiontests/RacksTest.java | 4 +- .../StratifiedEvaluationRegressionTest.java | 2 +- .../util/RegressionTestConfigProvider.java | 80 ++++------ .../util/RegressionTestUtils.java | 14 +- 35 files changed, 279 insertions(+), 373 deletions(-) delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{NormalizeProgramTransformation.java => ProgramNormalizer.java} (82%) delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java create mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java index 60dd0a236..eae27ca05 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.api; import java.io.IOException; +import java.io.InputStream; import java.nio.file.Path; import java.util.List; import java.util.Map; @@ -60,6 +61,16 @@ public interface Alpha { */ InputProgram readProgramString(String aspString); + /** + * Parses an ASP program from an input stream. + */ + InputProgram readProgramStream(InputStream is) throws IOException; + + /** + * Parses an ASP program from an input stream. + */ + InputProgram readProgramStream(InputStream is, Map externals) throws IOException; + /** * Prepares a {@link DebugSolvingContext} for the given {@link ASPCore2Program} to debug program preprocessing. * @@ -92,6 +103,7 @@ public interface Alpha { /** * Solves the given {@link ASPCore2Program}. + * * @param program an input program * @return a {@link Stream} of {@link AnswerSet}s of the given program */ @@ -99,14 +111,16 @@ public interface Alpha { /** * Solves the given {@link ASPCore2Program}. + * * @param program an input program - * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. + * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link Stream} of {@link AnswerSet}s of the given program */ Stream solve(InputProgram program, java.util.function.Predicate filter); /** * Solves the given {@link NormalProgram}. + * * @param program an input program * @return a {@link Stream} of {@link AnswerSet}s of the given program */ @@ -114,34 +128,39 @@ public interface Alpha { /** * Solves the given {@link NormalProgram}. + * * @param program an input program - * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. + * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link Stream} of {@link AnswerSet}s of the given program */ Stream solve(NormalProgram program, java.util.function.Predicate filter); /** - * Normalizes a program, i.e. rewrites all syntax constructs not natively supported by Alphas back-end into semantically equivalent ASP code. + * Normalizes a program, i.e. rewrites all syntax constructs not natively supported by Alphas back-end into semantically equivalent ASP + * code. * See {@link NormalProgram}, + * * @param program An {@link ASPCore2Program} to normalize * @return a {@link NormalProgram} that is a semantic equivalent to the given input program */ NormalProgram normalizeProgram(InputProgram program); /** - * Constructs a @{link Solver} pre-loaded with the given {@link ASPCore2Program} from which {@link AnswerSet}s can be obtained via {@link Solver#stream()}. + * Constructs a @{link Solver} pre-loaded with the given {@link ASPCore2Program} from which {@link AnswerSet}s can be obtained via + * {@link Solver#stream()}. * * @param program the program to solve - * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. + * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link Solver} pre-loaded withthe given program */ Solver prepareSolverFor(InputProgram program, java.util.function.Predicate filter); /** - * Constructs a @{link Solver} pre-loaded with the given {@link NormalProgram} from which {@link AnswerSet}s can be obtained via {@link Solver#stream()}. + * Constructs a @{link Solver} pre-loaded with the given {@link NormalProgram} from which {@link AnswerSet}s can be obtained via + * {@link Solver#stream()}. * * @param program the program to solve - * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. + * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link Solver} pre-loaded withthe given program */ Solver prepareSolverFor(NormalProgram program, java.util.function.Predicate filter); diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java index 4fd32e07e..d94f45969 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java @@ -80,7 +80,7 @@ public static void main(String[] args) { Main.exitWithMessage(commandLineParser.getUsageMessage(), 1); } - Alpha alpha = AlphaFactory.newAlpha(cfg.getSystemConfig()); + Alpha alpha = new AlphaFactory().newAlpha(cfg.getSystemConfig()); InputProgram program = null; try { diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java index 8b68d0dc1..865186191 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java @@ -122,9 +122,6 @@ public class CommandLineParser { private static final Option OPT_AGGREGATES_NO_NEGATIVE_INTEGERS = Option.builder("dni").longOpt("disableNegativeIntegers") .desc("use simplified encodings without netagive integer support for #sum aggregates (default: " + !AggregateRewritingConfig.DEFAULT_SUPPORT_NEGATIVE_INTEGERS + ")") .build(); - private static final Option OPT_NO_EVAL_STRATIFIED = Option.builder("dse").longOpt("disableStratifiedEvaluation") - .desc("Disable stratified evaluation") - .build(); private static final Option OPT_NO_NOGOOD_DELETION = Option.builder("dnd").longOpt("disableNoGoodDeletion") .desc("disable the deletion of (learned, little active) nogoods (default: " + SystemConfig.DEFAULT_DISABLE_NOGOOD_DELETION + ")") @@ -177,7 +174,6 @@ public class CommandLineParser { CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_AGGREGATES_NO_SORTING_GRID); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_AGGREGATES_NO_NEGATIVE_INTEGERS); - CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_NO_EVAL_STRATIFIED); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_NO_NOGOOD_DELETION); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER_TOLERANCE_CONSTRAINTS); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER_TOLERANCE_RULES); @@ -232,7 +228,6 @@ private void initializeGlobalOptionHandlers() { this.globalOptionHandlers.put(CommandLineParser.OPT_NO_JUSTIFICATION.getOpt(), this::handleNoJustification); this.globalOptionHandlers.put(CommandLineParser.OPT_AGGREGATES_NO_SORTING_GRID.getOpt(), this::handleDisableSortingGrid); this.globalOptionHandlers.put(CommandLineParser.OPT_AGGREGATES_NO_NEGATIVE_INTEGERS.getOpt(), this::handleDisableNegativeSumElements); - this.globalOptionHandlers.put(CommandLineParser.OPT_NO_EVAL_STRATIFIED.getOpt(), this::handleDisableStratifedEval); this.globalOptionHandlers.put(CommandLineParser.OPT_NO_NOGOOD_DELETION.getOpt(), this::handleNoNoGoodDeletion); this.globalOptionHandlers.put(CommandLineParser.OPT_GROUNDER_TOLERANCE_CONSTRAINTS.getOpt(), this::handleGrounderToleranceConstraints); this.globalOptionHandlers.put(CommandLineParser.OPT_GROUNDER_TOLERANCE_RULES.getOpt(), this::handleGrounderToleranceRules); @@ -423,10 +418,6 @@ private void handleDisableNegativeSumElements(Option opt, SystemConfig cfg) { cfg.getAggregateRewritingConfig().setSupportNegativeValuesInSums(false); } - private void handleDisableStratifedEval(Option opt, SystemConfig cfg) { - cfg.setEvaluateStratifiedPart(false); - } - private void handleDebugPreprocessing(Option opt, InputConfig cfg) { cfg.setDebugPreprocessing(true); } diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java index 23655f106..9c5777159 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java @@ -54,7 +54,7 @@ public void smokeTest() { "n1 -> n5 [xlabel=\"-\" labeldistance=0.1]" + LS + "n2 -> n5 [xlabel=\"+\" labeldistance=0.1]" + LS + "}" + LS; - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); DebugSolvingContext dbgResult = alpha.prepareDebugSolve(alpha.readProgramString(asp)); ComponentGraph compgraph = dbgResult.getComponentGraph(); ComponentGraphWriter writer = new ComponentGraphWriter(); diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java index 8d5929e80..a738bf3e0 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java @@ -51,7 +51,7 @@ public void smokeTest() { "n6 -> n4 [xlabel=\"+\" labeldistance=0.1]" + LS + "n6 -> n5 [xlabel=\"+\" labeldistance=0.1]" + LS + "}" + LS; - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); DebugSolvingContext dbgResult = alpha.prepareDebugSolve(alpha.readProgramString(asp)); DependencyGraph depgraph = dbgResult.getDependencyGraph(); DependencyGraphWriter writer = new DependencyGraphWriter(); diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParserTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParserTest.java index f77f6527e..91a2855b9 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParserTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParserTest.java @@ -28,7 +28,6 @@ package at.ac.tuwien.kr.alpha.app.config; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -160,20 +159,6 @@ public void noInstanceRemoval() throws ParseException { assertTrue(alphaConfig.getSystemConfig().isGrounderAccumulatorEnabled()); } - @Test - public void disableStratifiedEval() throws ParseException { - CommandLineParser parser = new CommandLineParser(DEFAULT_COMMAND_LINE, DEFAULT_ABORT_ACTION); - AlphaConfig ctx = parser.parseCommandLine(new String[]{"-i", "someFile.asp", "-i", "someOtherFile.asp", "-dse"}); - assertFalse(ctx.getSystemConfig().isEvaluateStratifiedPart()); - } - - @Test - public void disableStratifiedEvalLongOpt() throws ParseException { - CommandLineParser parser = new CommandLineParser(DEFAULT_COMMAND_LINE, DEFAULT_ABORT_ACTION); - AlphaConfig ctx = parser.parseCommandLine(new String[]{"-i", "someFile.asp", "-i", "someOtherFile.asp", "--disableStratifiedEvaluation"}); - assertFalse(ctx.getSystemConfig().isEvaluateStratifiedPart()); - } - @Test public void atomSeparator() throws ParseException { CommandLineParser parser = new CommandLineParser(DEFAULT_COMMAND_LINE, DEFAULT_ABORT_ACTION); diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java index 75a2d7cb6..c272d1ec3 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java @@ -47,7 +47,7 @@ public void solveAndWriteWorkbookTest() { + "p(N) :- p(I), N = I + 1, N <= MX, maxP(MX)." + "q(A, B) :- p(A), p(B)."; //@formatter:on - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); List answerSets = alpha.solve(alpha.readProgramString(progstr)).collect(Collectors.toList()); assertEquals(1, answerSets.size()); AnswerSet as = answerSets.get(0); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java index 17684b602..2dd9f0f5c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java @@ -36,6 +36,10 @@ public AbstractProgramParser(Map externals) { this.preloadedExternals.putAll(externals); } + protected void registerExternal(String name, PredicateInterpretation interpretation) { + this.preloadedExternals.put(name, interpretation); + } + @Override public InputProgram parse(String s) { return parse(s, Collections.emptyMap()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java index 9f1079922..3b1a9f71c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java @@ -1,18 +1,22 @@ package at.ac.tuwien.kr.alpha.core.parser.evolog; +import java.util.Collections; import java.util.Map; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; public class EvologProgramParser extends AbstractProgramParser { - public EvologProgramParser(Map externals) { + public EvologProgramParser(ActionImplementationProvider actionImplementationProvider, Map externals) { super(externals); + registerExternal("stdin", actionImplementationProvider.getStdinTerm()); + registerExternal("stdout", actionImplementationProvider.getStdoutTerm()); } - public EvologProgramParser() { - super(); + public EvologProgramParser(ActionImplementationProvider actionImplementationProvider) { + this(actionImplementationProvider, Collections.emptyMap()); } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java deleted file mode 100644 index 83e9ab9c9..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java +++ /dev/null @@ -1,26 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs; - -import java.io.IOException; -import java.io.InputStream; -import java.util.Map; - -import org.antlr.v4.runtime.CharStreams; - -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; - -public class Programs { - - private Programs() { - throw new AssertionError("This is a pure utility class and should therefore not be instantiated!"); - } - - // TODO integrate this Method into Alpha interface so we have a parser following overall system config - public static InputProgram fromInputStream(InputStream is, Map externals) throws IOException { - AbstractProgramParser parser = new EvologProgramParser(); - return parser.parse(CharStreams.fromStream(is), externals); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java similarity index 82% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java index 1d075903e..89498e3da 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java @@ -11,7 +11,7 @@ * * Copyright (c) 2019-2021, the Alpha Team. */ -public class NormalizeProgramTransformation extends ProgramTransformer { +public class ProgramNormalizer extends ProgramTransformer { private final VariableEqualityTransformer equalityTransformer; private final ChoiceHeadNormalizer choiceHeadNormalizer; @@ -20,7 +20,7 @@ public class NormalizeProgramTransformation extends ProgramTransformer solvedRuleIds = new HashSet<>(); // Set of rules that have been completely evaluated. private LiteralInstantiator literalInstantiator; - private ActionExecutionService actionContext; + private ActionExecutionService actionExecutionService; private final boolean generateActionWitnesses; - public StratifiedEvaluation(ActionExecutionService actionContext, boolean generateActionWitnesses) { - this.actionContext = actionContext; + public StratifiedEvaluation(ActionExecutionService actionExecutionService, boolean generateActionWitnesses) { + this.actionExecutionService = actionExecutionService; this.generateActionWitnesses = generateActionWitnesses; } @@ -352,7 +352,7 @@ public BasicAtom instantiateActionHead(ActionHead head, Substitution substitutio substitutedInput.add(inputTerm.substitute(substitution)); } // Delegate action execution to respective backend. - ActionWitness witness = actionContext.execute(head.getActionName(), rule.getRuleId(), substitution, substitutedInput); + ActionWitness witness = actionExecutionService.execute(head.getActionName(), rule.getRuleId(), substitution, substitutedInput); // If the according debug flag is set, convert witness to atom and add to facts. if (generateActionWitnesses) { BasicAtom witnessAtom = buildActionWitnessAtom(witness, rule); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java deleted file mode 100644 index c1a6ad17e..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoderFactory.java +++ /dev/null @@ -1,44 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; - -import java.util.function.Supplier; - -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; - -public class AggregateEncoderFactory { - - private final Supplier parserFactory; - private final boolean useSortingGridEncoding; - private final boolean supportNegativeSumElements; - - public AggregateEncoderFactory(Supplier parserFactory, boolean useSortingGridEncoding, boolean supportNegativeSumElements) { - this.parserFactory = parserFactory; - this.useSortingGridEncoding = useSortingGridEncoding; - this.supportNegativeSumElements = supportNegativeSumElements; - } - - public CountEncoder newCountEqualsEncoder() { - return CountEncoder.buildCountEqualsEncoder(parserFactory.get()); - } - - public CountEncoder newCountLessOrEqualEncoder() { - return CountEncoder.buildCountLessOrEqualEncoder(parserFactory.get(), useSortingGridEncoding); - } - - public SumEncoder newSumEqualsEncoder() { - return SumEncoder.buildSumEqualsEncoder(parserFactory.get(), supportNegativeSumElements); - } - - public SumEncoder newSumLessOrEqualEncoder() { - return SumEncoder.buildSumLessOrEqualEncoder(parserFactory.get(), supportNegativeSumElements); - } - - public MinMaxEncoder newMinEncoder() { - return new MinMaxEncoder(parserFactory.get(), AggregateFunctionSymbol.MIN); - } - - public MinMaxEncoder newMaxEncoder() { - return new MinMaxEncoder(parserFactory.get(), AggregateFunctionSymbol.MAX); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java new file mode 100644 index 000000000..55d6ca6af --- /dev/null +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java @@ -0,0 +1,36 @@ +package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; + +import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; + +public final class AggregateEncoders { + + private AggregateEncoders() { + throw new AssertionError("Cannot instantiate utility class!"); + } + + public static CountEncoder newCountEqualsEncoder(ProgramParser parser) { + return CountEncoder.buildCountEqualsEncoder(parser); + } + + public static CountEncoder newCountLessOrEqualEncoder(ProgramParser parser, boolean useSortingGridEncoding) { + return CountEncoder.buildCountLessOrEqualEncoder(parser, useSortingGridEncoding); + } + + public static SumEncoder newSumEqualsEncoder(ProgramParser parser, boolean supportNegativeSumElements) { + return SumEncoder.buildSumEqualsEncoder(parser, supportNegativeSumElements); + } + + public static SumEncoder newSumLessOrEqualEncoder(ProgramParser parser, boolean supportNegativeSumElements) { + return SumEncoder.buildSumLessOrEqualEncoder(parser, supportNegativeSumElements); + } + + public static MinMaxEncoder newMinEncoder(ProgramParser parser) { + return new MinMaxEncoder(parser, AggregateFunctionSymbol.MIN); + } + + public static MinMaxEncoder newMaxEncoder(ProgramParser parser) { + return new MinMaxEncoder(parser, AggregateFunctionSymbol.MAX); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index e78acb4bd..74b10bb47 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -62,7 +62,7 @@ public class MinMaxEncoder extends AbstractAggregateEncoder { private final ProgramParser parser; - public MinMaxEncoder(ProgramParser parser, AggregateFunctionSymbol func) { + MinMaxEncoder(ProgramParser parser, AggregateFunctionSymbol func) { super(func, SetUtils.hashSet(ComparisonOperators.operators())); if (!(func == AggregateFunctionSymbol.MAX || func == AggregateFunctionSymbol.MIN)) { throw new IllegalArgumentException("Encoder " + this.getClass().getSimpleName() + " can only encode min/max aggregates!"); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java index 95d9737a3..4a5a9497d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java @@ -37,11 +37,11 @@ private SumEncoder(ProgramParser parser, ComparisonOperator acceptedOperator, ST super(parser, AggregateFunctionSymbol.SUM, acceptedOperator, encodingTemplate); } - public static SumEncoder buildSumLessOrEqualEncoder(ProgramParser parser, boolean supportNegativeIntegers) { + static SumEncoder buildSumLessOrEqualEncoder(ProgramParser parser, boolean supportNegativeIntegers) { return new SumEncoder(parser, ComparisonOperators.LE, supportNegativeIntegers ? SUM_LE_TEMPLATE : NON_NEG_ELEMENTS_SUM_LE_TEMPLATE); } - public static SumEncoder buildSumEqualsEncoder(ProgramParser parser, boolean supportNegativeIntegers) { + static SumEncoder buildSumEqualsEncoder(ProgramParser parser, boolean supportNegativeIntegers) { return new SumEncoder(parser, ComparisonOperators.EQ, supportNegativeIntegers ? SUM_EQ_TEMPLATE : NON_NEG_ELEMENTS_SUM_EQ_TEMPLATE); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java index 5621615cc..69e7eb0b7 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java @@ -1,11 +1,12 @@ package at.ac.tuwien.kr.alpha.core.parser; +import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; public class EvologParserTest extends ParserTest { protected EvologParserTest() { - super(new EvologProgramParser()); + super(new EvologProgramParser(new DefaultActionImplementationProvider())); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index 1e2566d52..db77b46d8 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -16,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; // TODO This is a functional test and should not be run with standard unit tests @@ -26,8 +26,8 @@ public class ProgramTransformationTest { private static final String TESTFILES_PATH = "/transform-test/"; - // TODO should this always be an evolog parser? - private static final ProgramParser PARSER = new EvologProgramParser(); + // TODO should this always be an asp core2 parser? + private static final ProgramParser PARSER = new ASPCore2ProgramParser(); private ChoiceHeadNormalizer choiceToNormal = new ChoiceHeadNormalizer(); private IntervalTermTransformer intervalRewriting = new IntervalTermTransformer(); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index aeb0fed9e..b3c014c13 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -2,8 +2,6 @@ import java.util.function.Supplier; -import com.google.common.annotations.VisibleForTesting; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; @@ -11,45 +9,51 @@ import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionServiceImpl; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermTransformer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ChoiceHeadNormalizer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationTransformer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.IntervalTermTransformer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramNormalizer; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformer; +import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.VariableEqualityTransformer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AggregateEncoderFactory; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AggregateEncoders; import at.ac.tuwien.kr.alpha.core.solver.SolverConfig; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; import at.ac.tuwien.kr.alpha.core.solver.heuristics.HeuristicsConfiguration; -public final class AlphaFactory { - - private AlphaFactory() { - throw new AssertionError("Cannot instantiate utility class!"); - } +public class AlphaFactory { - static Supplier> newProgramNormalizationFactory(Supplier parserFactory, + protected ProgramTransformer newProgramNormalizer(ProgramParser parser, AggregateRewritingConfig aggregateCfg) { - // AggregateEncoderFactory depends on parser factory since stringtemplate-based aggregate encoders need to use the same parser that's used - // for input programs. - AggregateEncoderFactory aggregateEncoderFactory = new AggregateEncoderFactory(parserFactory, - aggregateCfg.isUseSortingGridEncoding(), aggregateCfg.isSupportNegativeValuesInSums()); - - // Factory for aggregate rewriting (depends on encoders provided by above factory). - Supplier aggregateRewritingFactory = () -> new AggregateTransformer(aggregateEncoderFactory.newCountEqualsEncoder(), - aggregateEncoderFactory.newCountLessOrEqualEncoder(), aggregateEncoderFactory.newSumEqualsEncoder(), - aggregateEncoderFactory.newSumLessOrEqualEncoder(), aggregateEncoderFactory.newMinEncoder(), aggregateEncoderFactory.newMaxEncoder()); + return new ProgramNormalizer( + new VariableEqualityTransformer(), + new ChoiceHeadNormalizer(), + new AggregateTransformer( + AggregateEncoders.newCountEqualsEncoder(parser), + AggregateEncoders.newCountLessOrEqualEncoder(parser, aggregateCfg.isUseSortingGridEncoding()), + AggregateEncoders.newSumEqualsEncoder(parser, aggregateCfg.isSupportNegativeValuesInSums()), + AggregateEncoders.newSumLessOrEqualEncoder(parser, aggregateCfg.isSupportNegativeValuesInSums()), + AggregateEncoders.newMinEncoder(parser), + AggregateEncoders.newMaxEncoder(parser)), + new EnumerationTransformer(), + new IntervalTermTransformer(), + new ArithmeticTermTransformer()); + } - // Factory for NormalizeProgramTransformation - needs a supplier for AggregateRewriting due to AggregateRewritings' dependency to encoder - // factory. - return () -> new NormalizeProgramTransformation( - aggregateRewritingFactory); + protected Supplier newStratifiedEvaluationFactory(ActionImplementationProvider actionImplementationProvider, + boolean generateActionWitnesses) { + return () -> new StratifiedEvaluation(new ActionExecutionServiceImpl(actionImplementationProvider), generateActionWitnesses); } - static GrounderFactory newGrounderFactory(SystemConfig cfg) { + protected GrounderFactory newGrounderFactory(SystemConfig cfg) { GrounderHeuristicsConfiguration grounderHeuristicsCfg = GrounderHeuristicsConfiguration.getInstance(cfg.getGrounderToleranceConstraints(), cfg.getGrounderToleranceRules()); grounderHeuristicsCfg.setAccumulatorEnabled(cfg.isGrounderAccumulatorEnabled()); @@ -58,7 +62,7 @@ static GrounderFactory newGrounderFactory(SystemConfig cfg) { cfg.isDebugInternalChecks()); } - static SolverFactory newSolverFactory(SystemConfig cfg) { + protected SolverFactory newSolverFactory(SystemConfig cfg) { SolverConfig solverCfg = new SolverConfig(); solverCfg.setDisableJustifications(cfg.isDisableJustificationSearch()); solverCfg.setDisableNogoodDeletion(cfg.isDisableNoGoodDeletion()); @@ -73,18 +77,25 @@ static SolverFactory newSolverFactory(SystemConfig cfg) { return new SolverFactory(cfg.getSolverName(), cfg.getNogoodStoreName(), solverCfg); } - // TODO lifetime of one ActionContext needs to be exactly runtime of one program! - @VisibleForTesting - public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionContext) { - - // Parser factory - Supply correct parser dependent on the accepted input language. - Supplier parserFactory = () -> cfg.isAcceptEvologPrograms() ? new EvologProgramParser() : new ASPCore2ProgramParser(); - // if (cfg.isAcceptEvologPrograms()) { + protected ActionImplementationProvider newActionImplementationProvider() { + return new DefaultActionImplementationProvider(); + } - // } - Supplier> programNormalizationFactory = newProgramNormalizationFactory(parserFactory, + public Alpha newAlpha(SystemConfig cfg) { + ActionImplementationProvider actionImplementationProvider = newActionImplementationProvider(); + ProgramParser parser; + if (cfg.isAcceptEvologPrograms()) { + parser = new EvologProgramParser(actionImplementationProvider); // TODO need to give stdin/stdout definitions to parser (pass in implementation + // provider) + } else { + parser = new ASPCore2ProgramParser(); + } + ProgramTransformer programNormalizer = newProgramNormalizer(parser, cfg.getAggregateRewritingConfig()); + // Stratified evaluation factory - since every instance of stratified evaluation is only good for one program, we need a factory. + Supplier stratifiedEvaluationFactory = newStratifiedEvaluationFactory(actionImplementationProvider, cfg.isDebugInternalChecks()); + // GrounderFactory - Since every grounder instance is only good for one program instance, we need a factory. GrounderFactory grounderFactory = newGrounderFactory(cfg); @@ -92,17 +103,11 @@ public static Alpha newAlpha(SystemConfig cfg, ActionExecutionService actionCont SolverFactory solverFactory = newSolverFactory(cfg); // Now that all dependencies are taken care of, build new Alpha instance. - return new AlphaImpl(parserFactory, programNormalizationFactory, grounderFactory, solverFactory, actionContext, cfg.isEvaluateStratifiedPart(), - cfg.isSortAnswerSets()); - } - - // TODO action stuff should go into system config - public static Alpha newAlpha(SystemConfig cfg) { - return newAlpha(cfg, new ActionExecutionServiceImpl(new DefaultActionImplementationProvider())); + return new AlphaImpl(parser, programNormalizer, stratifiedEvaluationFactory, grounderFactory, solverFactory, cfg.isSortAnswerSets()); } // Create Alpha instance with default config. - public static Alpha newAlpha() { + public Alpha newAlpha() { return newAlpha(new SystemConfig()); } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 5bb5d1621..a95276fe7 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -40,12 +40,12 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import com.google.common.annotations.VisibleForTesting; - import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.annotations.VisibleForTesting; + import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; @@ -59,7 +59,6 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; @@ -76,21 +75,23 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); - private final Supplier parserFactory; - private final Supplier> programNormalizationFactory; + private final ProgramParser parser; + private final ProgramTransformer programNormalizer; + private final Supplier stratifiedEvaluationFactory; private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; private final boolean sortAnswerSets; - AlphaImpl(Supplier parserFactory, Supplier> programNormalizationFactory, + AlphaImpl(ProgramParser parser, ProgramTransformer programNormalizer, + Supplier stratifiedEvaluationFactory, GrounderFactory grounderFactory, - SolverFactory solverFactory, - boolean enableStratifiedEvaluation, boolean sortAnswerSets) { - this.parserFactory = parserFactory; - this.programNormalizationFactory = programNormalizationFactory; + SolverFactory solverFactory, boolean sortAnswerSets) { + this.parser = parser; + this.programNormalizer = programNormalizer; + this.stratifiedEvaluationFactory = stratifiedEvaluationFactory; this.grounderFactory = grounderFactory; this.solverFactory = solverFactory; this.sortAnswerSets = sortAnswerSets; @@ -119,7 +120,6 @@ public InputProgram readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException { - ProgramParser parser = parserFactory.get(); InputProgramImpl.Builder prgBuilder = InputProgramImpl.builder(); InputProgram tmpProg; for (Path path : paths) { @@ -137,7 +137,7 @@ public InputProgram readProgramFiles(boolean literate, Map externals) { - return parserFactory.get().parse(aspString, externals); + return parser.parse(aspString, externals); } @Override @@ -145,18 +145,27 @@ public InputProgram readProgramString(String aspString) { return readProgramString(aspString, Collections.emptyMap()); } + @Override + public InputProgram readProgramStream(InputStream is) throws IOException { + return parser.parse(is); + } + + @Override + public InputProgram readProgramStream(InputStream is, Map externals) throws IOException { + return parser.parse(is, externals); + } + @Override public NormalProgram normalizeProgram(InputProgram program) { - return programNormalizationFactory.get().transform(program); + return programNormalizer.transform(program); } @VisibleForTesting InternalProgram performProgramPreprocessing(NormalProgram program) { LOGGER.debug("Preprocessing InternalProgram!"); InternalProgram retVal = InternalProgram.fromNormalProgram(program); - // TODO get the StratifiedEvaluation from factory AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); - retVal = new StratifiedEvaluation(actionContext, true).transform(analyzed); + retVal = stratifiedEvaluationFactory.get().transform(analyzed); return retVal; } @@ -242,8 +251,7 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final ComponentGraph compGraph; final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; - // TODO get the StratifiedEvaluation from factory - preprocessed = new StratifiedEvaluation(actionContext, true).transform(analyzed).toNormalProgram(); + preprocessed = stratifiedEvaluationFactory.get().transform(analyzed).toNormalProgram(); depGraph = analyzed.getDependencyGraph(); compGraph = analyzed.getComponentGraph(); final Solver solver = prepareSolverFor(analyzed, filter); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 0b61309b1..f0a25b778 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -28,7 +28,7 @@ public class ActionsTest { public void helloWorld() { MockActionImplementationProvider actionMock = new MockActionImplementationProvider(); ActionExecutionService actionService = new ActionExecutionServiceImpl(actionMock); - Alpha alpha = AlphaFactory.newAlpha(new SystemConfig(), actionService); + Alpha alpha = new AlphaFactory().newAlpha(new SystemConfig()); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); // TODO check mock for correct output content diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java index 0acbb173a..4114d032d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java @@ -18,7 +18,7 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -60,7 +60,7 @@ public class AggregateRewritingContextTest { //@formatter:on private static final AggregateRewritingContext rewritingContextForAspString(String asp) { - InputProgram program = new EvologProgramParser().parse(asp); + InputProgram program = new ASPCore2ProgramParser().parse(asp); AggregateRewritingContext ctx = new AggregateRewritingContext(); for (Rule rule : program.getRules()) { ctx.registerRule(rule); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java index df015f477..c3e9e3b90 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java @@ -79,7 +79,7 @@ public class AggregateRewritingTest { //@formatter:on // Use an alpha instance with default config for all test cases - private final Alpha alpha = AlphaFactory.newAlpha(); + private final Alpha alpha = new AlphaFactory().newAlpha(); private final Function> solve = (asp) -> { InputProgram prog = alpha.readProgramString(asp); return alpha.solve(prog).collect(Collectors.toList()); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index 637fe75a1..4df809080 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -23,7 +23,7 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermTransformer; @@ -34,7 +34,7 @@ public class ArithmeticTermsRewritingTest { private final Map externalsOfThisClass = Externals.scan(ArithmeticTermsRewritingTest.class); - private final ProgramParser parser = new EvologProgramParser(externalsOfThisClass); // Create parser that knows an implementation of external atom &extArithTest[](). + private final ProgramParser parser = new ASPCore2ProgramParser(externalsOfThisClass); // Create parser that knows an implementation of external atom &extArithTest[](). @Predicate(name = "extArithTest") public static Set>> externalForArithmeticTermsRewriting(Integer in) { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java index 0aafb40c7..871b20491 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java @@ -81,7 +81,7 @@ public static Set>> connection(String dummy) { private Map externals; public FixedInterpretationLiteralsTest() { - this.alpha = AlphaFactory.newAlpha(); + this.alpha = new AlphaFactory().newAlpha(); this.externals = new HashMap<>(); this.externals.putAll(Externals.scan(AspStandardLibrary.class)); this.externals.putAll(Externals.scan(FixedInterpretationLiteralsTest.class)); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java index 69982ad45..f379a2a30 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java @@ -4,12 +4,12 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; public class RuleParser { public static Rule parse(String str) { - ProgramParser parser = new EvologProgramParser(); + ProgramParser parser = new ASPCore2ProgramParser(); InputProgram prog = parser.parse(str); if (!prog.getFacts().isEmpty()) { throw new IllegalArgumentException("Expected exactly one rule and no facts!"); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index aadbd8588..d2f2e9dfd 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -36,7 +36,7 @@ import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRuleImpl; import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; @@ -45,7 +45,7 @@ * Tests {@link BasicRule#toString()} and {@link CompiledRuleImpl#toString()}. */ public class RuleToStringTest { - private final ProgramParser parser = new EvologProgramParser(); + private final ProgramParser parser = new ASPCore2ProgramParser(); @Test public void positiveRuleToString() { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java index 1a53a980f..ff80432b6 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java @@ -27,11 +27,10 @@ */ package at.ac.tuwien.kr.alpha; +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; - import java.io.IOException; import java.util.HashMap; import java.util.List; @@ -45,7 +44,6 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; @@ -56,13 +54,12 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.Programs; // TODO This is an integration test and should be run in an extra suite public class StratifiedEvaluationTest { // Alpha instance with default configuration (evolog support and stratified evaluation enabled) - private final Alpha alpha = AlphaFactory.newAlpha(); + private final Alpha alpha = new AlphaFactory().newAlpha(); /** * Verifies that facts are not duplicated by stratified evaluation. @@ -160,7 +157,7 @@ public void testNegatedExternalLiteral() throws Exception { */ @Test public void testPartnerUnitsProblemTopologicalOrder() throws IOException { - InputProgram prg = Programs.fromInputStream( + InputProgram prg = alpha.readProgramStream( StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/pup_topological_order.asp"), new HashMap<>()); DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(prg); @@ -184,24 +181,13 @@ public void testNegatedLiteralInRecursiveRule() throws IOException { + "inc_value(4), inc_value(5), inc_value(6), inc_value(7), " + "inc_value(8)"; //@formatter:on - InputProgram prog = Programs.fromInputStream( + InputProgram prog = alpha.readProgramStream( StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/recursive_w_negated_condition.asp"), new HashMap<>()); // Run stratified evaluation and solve - SystemConfig cfgWithStratEval = new SystemConfig(); - cfgWithStratEval.setEvaluateStratifiedPart(true); - Alpha alphaStratEval = AlphaFactory.newAlpha(cfgWithStratEval); - DebugSolvingContext dbgWithStratEval = alphaStratEval.prepareDebugSolve(prog); - Set asStrat = dbgWithStratEval.getSolver().collectSet(); - assertAnswerSetsEqual(expectedAnswerSet, asStrat); - - // Solve without stratified evaluation - SystemConfig cfgNoStratEval = new SystemConfig(); - cfgNoStratEval.setEvaluateStratifiedPart(false); - Alpha alphaNoStratEval = AlphaFactory.newAlpha(cfgNoStratEval); - DebugSolvingContext dbgNoStratEval = alphaNoStratEval.prepareDebugSolve(prog); - Set as = dbgNoStratEval.getSolver().collectSet(); + DebugSolvingContext dbg = alpha.prepareDebugSolve(prog); + Set as = dbg.getSolver().collectSet(); assertAnswerSetsEqual(expectedAnswerSet, as); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 668dee7bb..9e365313d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -38,16 +38,12 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; -import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.nio.file.StandardOpenOption; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.List; -import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; @@ -58,12 +54,11 @@ import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.config.Heuristic; +import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; import at.ac.tuwien.kr.alpha.api.config.InputConfig; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; @@ -79,16 +74,14 @@ import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; // TODO This is a functional test and should not be run with standard unit tests public class AlphaImplTest { - + private static final Logger LOGGER = LoggerFactory.getLogger(AspStandardLibrary.class); - + //@formatter:off private static final String STRINGSTUFF_ASP = "string(\"bla\")." @@ -118,7 +111,7 @@ public class AlphaImplTest { //@formatter:on private static int invocations; - + @at.ac.tuwien.kr.alpha.api.externals.Predicate public static boolean isOne(int term) { invocations++; @@ -138,7 +131,7 @@ public static boolean thinger(Thingy thingy) { @Test public void withExternal() throws Exception { - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("a :- &isOne[1]."); inputCfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram program = alpha.readProgram(inputCfg); @@ -149,7 +142,7 @@ public void withExternal() throws Exception { @Test public void addsFacts() { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); Thingy a = new Thingy(); Thingy b = new Thingy(); List things = asList(a, b); @@ -162,18 +155,18 @@ public void addsFacts() { @Test public void withExternalTypeConflict() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = AlphaFactory.newAlpha(); - InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); - inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); - Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); - Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); - assertEquals(expected, actual); -}); + Alpha system = new AlphaFactory().newAlpha(); + InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); + inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); + Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); + Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); + assertEquals(expected, actual); + }); } @Test public void smallGraph() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). node(3). a :- &connected[1,2]."); inputCfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); InputProgram program = system.readProgram(inputCfg); @@ -185,7 +178,7 @@ public void smallGraph() throws Exception { @Test public void filterOutput() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). outgoing13(X) :- node(X), &getLargeGraphEdges(13,X)."); inputCfg.addPredicateMethod("getLargeGraphEdges", Externals.processPredicate(() -> new HashSet<>(asList(asList(Terms.newConstant(1), Terms.newConstant(2)), @@ -198,7 +191,7 @@ public void filterOutput() throws Exception { @Test public void supplier() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicate(() -> singleton(singletonList(Terms.newConstant(1))))); InputProgram prog = system.readProgram(cfg); @@ -215,7 +208,7 @@ public static Set>> bestNode() { @Test public void noInput() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicateMethod(this.getClass().getMethod("bestNode"))); InputProgram prog = system.readProgram(cfg); @@ -228,12 +221,12 @@ public void noInput() throws Exception { @Test public void smallGraphWithWrongType() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = AlphaFactory.newAlpha(); - InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); - cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); - InputProgram prog = system.readProgram(cfg); + Alpha system = new AlphaFactory().newAlpha(); + InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); + cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); + InputProgram prog = system.readProgram(cfg); - system.solve(prog).collect(Collectors.toSet()); + system.solve(prog).collect(Collectors.toSet()); }); } @@ -254,7 +247,7 @@ public static Set>> coolNode(int node) { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphNoNeighbors() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("noNeighbors(2) :- not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -266,7 +259,7 @@ public void smallGraphNoNeighbors() throws Exception { @Test public void smallGraphCoolNode() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1..2). in(X) :- node(X), &coolNode[X]."); cfg.addPredicateMethod("coolNode", Externals.processPredicateMethod(this.getClass().getMethod("coolNode", int.class))); InputProgram prog = system.readProgram(cfg); @@ -278,7 +271,7 @@ public void smallGraphCoolNode() throws Exception { @Test public void smallGraphSingleNeighbor() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1..3). in(1,X) :- &neighbors[1](X), node(X)."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -291,7 +284,7 @@ public void smallGraphSingleNeighbor() throws Exception { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphSingleNeighborNoTerm() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("success :- &neighbors[1], not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -317,7 +310,7 @@ public boolean equals(Object o) { if (o == null) { return false; } - if (!(o instanceof Thingy)) { + if (!(o instanceof Thingy)) { return false; } return true; @@ -342,7 +335,7 @@ public void withExternalSubtype() throws Exception { new MethodPredicateInterpretation(this.getClass().getMethod("thinger", Thingy.class)), singletonList(Terms.newConstant(thingy)), emptyList()), true))); - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputProgram prog = new InputProgramImpl(singletonList(rule), emptyList(), new InlineDirectivesImpl()); @@ -353,7 +346,7 @@ public void withExternalSubtype() throws Exception { @Test public void withExternalViaAnnotation() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1]."); cfg.addPredicateMethods(Externals.scan(this.getClass())); InputProgram prog = system.readProgram(cfg); @@ -371,15 +364,15 @@ public void withExternalViaAnnotation() throws Exception { @Test public void errorDuplicateExternal() { assertThrows(IllegalArgumentException.class, () -> { - InputConfig cfg = InputConfig.forString("someString."); - cfg.addPredicateMethods(Externals.scan(this.getClass())); - cfg.addPredicateMethods(Externals.scan(this.getClass())); -}); + InputConfig cfg = InputConfig.forString("someString."); + cfg.addPredicateMethods(Externals.scan(this.getClass())); + cfg.addPredicateMethods(Externals.scan(this.getClass())); + }); } @Test public void withNativeExternal() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isTwo[2]."); cfg.addPredicateMethod("isTwo", Externals.processPredicate((Integer t) -> t == 2)); InputProgram prog = system.readProgram(cfg); @@ -392,7 +385,7 @@ public void withNativeExternal() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted1() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], &isOne[1]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -410,7 +403,7 @@ public void withExternalInvocationCounted1() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted2() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a. b :- &isOne[1], &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -428,7 +421,7 @@ public void withExternalInvocationCounted2() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted3() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], not &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -442,11 +435,11 @@ public void withExternalInvocationCounted3() throws Exception { Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); assertEquals(expected, actual); } - + @Test @SuppressWarnings("unchecked") public void programWithExternalStringStuff() throws IOException { - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); InputProgram prog = alpha.readProgram(InputConfig.forString(STRINGSTUFF_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); // Verify every result string has length 6 and contains "foo" @@ -462,7 +455,7 @@ public void programWithExternalStringStuff() throws IOException { @Test @SuppressWarnings("unchecked") public void withNegatedExternal() throws IOException { - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); InputProgram prog = alpha.readProgram(InputConfig.forString(NEGATED_EXTERNAL_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); assertEquals(31, answerSets.size()); @@ -479,7 +472,7 @@ public void withNegatedExternal() throws IOException { @Test public void basicUsage() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); Set actual = system.solve(system.readProgram(InputConfig.forString("p(a)."))).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").symbolicInstance("a").build())); assertEquals(expected, actual); @@ -487,7 +480,7 @@ public void basicUsage() throws Exception { @Test public void basicUsageWithString() throws Exception { - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); Set actual = system.solve(system.readProgram(InputConfig.forString("p(\"a\")."))).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").instance("a").build())); assertEquals(expected, actual); @@ -499,7 +492,7 @@ public void basicUsageWithString() throws Exception { @Test public void filterTest() { String progstr = "a. b. c. d :- c. e(a, b) :- d."; - Alpha system = AlphaFactory.newAlpha(); + Alpha system = new AlphaFactory().newAlpha(); InputProgram prog = system.readProgramString(progstr); Set actual = system.solve(prog, (p) -> p.equals(Predicates.getPredicate("a", 0)) || p.equals(Predicates.getPredicate("e", 2))) .collect(Collectors.toSet()); @@ -508,34 +501,18 @@ public void filterTest() { } /** - * Verifies that no stratified evaluation is performed up-front when disabled in config. - */ - @Test - public void disableStratifiedEvalTest() { - // Note: This might be cleaner if the test used the debugSolve method from the interface - String progstr = "p(a). q(X) :- p(X)."; - SystemConfig cfg = new SystemConfig(); - cfg.setEvaluateStratifiedPart(false); - AlphaImpl system = (AlphaImpl) AlphaFactory.newAlpha(cfg); - InputProgram input = system.readProgramString(progstr); - NormalProgram normal = system.normalizeProgram(input); - CompiledProgram preprocessed = system.performProgramPreprocessing(normal); - assertFalse(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), - "Preprocessed program contains fact derived from stratifiable rule, but should not!"); - } - - /** - * Verifies that stratified evaluation is performed up-front if not otherwise configured. + * Verifies that stratified evaluation is performed. + * Note: This test case is something of a bit of legacy code since there is no way to disable stratified evaluation anymore. */ @Test public void enableStratifiedEvalTest() { - // Note: This might be cleaner if the test used the debugSolve method from the interface String progstr = "p(a). q(X) :- p(X)."; SystemConfig cfg = new SystemConfig(); - AlphaImpl system = (AlphaImpl) AlphaFactory.newAlpha(cfg); + Alpha system = new AlphaFactory().newAlpha(cfg); InputProgram input = system.readProgramString(progstr); NormalProgram normal = system.normalizeProgram(input); - CompiledProgram preprocessed = system.performProgramPreprocessing(normal); + DebugSolvingContext dbg = system.prepareDebugSolve(normal); + NormalProgram preprocessed = dbg.getPreprocessedProgram(); assertTrue(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), "Preprocessed program does not contain fact derived from stratifiable rule, but should!"); } @@ -592,7 +569,7 @@ public void problematicRun_3col_1119718541727902_sorted_400() throws IOException cfg.setNogoodStoreName("alpharoaming"); cfg.setDebugInternalChecks(true); cfg.setSeed(1119718541727902L); - final Alpha system = AlphaFactory.newAlpha(cfg); + final Alpha system = new AlphaFactory().newAlpha(cfg); final Path path = Paths.get("src", "test", "resources", "PreviouslyProblematic").resolve("3col-20-38.txt"); InputConfig inputCfg = new InputConfig(); @@ -611,7 +588,7 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep cfg.setNogoodStoreName("alpharoaming"); cfg.setDebugInternalChecks(true); cfg.setSeed(seed); - final Alpha system = AlphaFactory.newAlpha(cfg); + final Alpha system = new AlphaFactory().newAlpha(cfg); InputConfig inputCfg = new InputConfig(); List files = new ArrayList<>(); files.add(base.resolve(program).toString()); @@ -619,31 +596,5 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep InputProgram prog = system.readProgram(inputCfg); assertFalse(system.solve(prog).limit(limit).collect(Collectors.toList()).isEmpty()); } - - // Detailed reproduction test-case for github issue #239. - @Test - public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { - final ProgramParser parser = new ASPCore2ProgramParser(); - InputProgramImpl.Builder bld = InputProgramImpl.builder(); - bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), StandardOpenOption.READ))); - bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); - InputProgram parsedProgram = bld.build(); - - SystemConfig config = new SystemConfig(); - config.setSolverName("default"); - config.setNogoodStoreName("alpharoaming"); - config.setSeed(0); - config.setBranchingHeuristic(Heuristic.valueOf("VSIDS")); - config.setDebugInternalChecks(true); - config.setDisableJustificationSearch(false); - config.setEvaluateStratifiedPart(false); - config.setReplayChoices(Arrays.asList(21, 26, 36, 56, 91, 96, 285, 166, 101, 290, 106, 451, 445, 439, 448, - 433, 427, 442, 421, 415, 436, 409, 430, 397, 391, 424, 385, 379, - 418, 373, 412, 406, 394, 388, 382, 245, 232, 208 - )); - Alpha alpha = AlphaFactory.newAlpha(config); - Optional answerSet = alpha.solve(parsedProgram).findFirst(); - assertTrue(answerSet.isPresent()); - } - + } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java index 36f0f1ecc..da9238e66 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java @@ -42,7 +42,7 @@ import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** * Tests rule transformations described in the following research paper, and their effects on performance: @@ -246,7 +246,7 @@ private InputProgram constructProgramA_TransformationA(int n) { private InputProgram checkNumberOfRulesAndParse(List strRules, int numberOfRules) { assertEquals(numberOfRules, strRules.size()); String strProgram = strRules.stream().collect(Collectors.joining(System.lineSeparator())); - InputProgram parsedProgram = new EvologProgramParser().parse(strProgram); + InputProgram parsedProgram = new ASPCore2ProgramParser().parse(strProgram); assertEquals(numberOfRules, parsedProgram.getRules().size()); return parsedProgram; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java index c481b4a99..a8d9d79d0 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java @@ -41,7 +41,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -112,7 +112,7 @@ public void testReach_4(SystemConfig cfg) { private void test(String folder, String aspFileName, SystemConfig cfg) throws IOException { @SuppressWarnings("unused") Optional answerSet = buildSolverForRegressionTest( - new EvologProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) + new ASPCore2ProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) .stream().findFirst(); // System.out.println(answerSet); // TODO: check correctness of answer set diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java index ecdb85095..070177f4e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java @@ -39,7 +39,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -61,7 +61,7 @@ public void testRacks(SystemConfig cfg) { private void test(SystemConfig cfg) throws IOException { CharStream programInputStream = CharStreams.fromPath( Paths.get("benchmarks", "siemens", "racks", "racks.lp")); - Solver solver = buildSolverForRegressionTest(new EvologProgramParser().parse(programInputStream), cfg); + Solver solver = buildSolverForRegressionTest(new ASPCore2ProgramParser().parse(programInputStream), cfg); @SuppressWarnings("unused") Optional answerSet = solver.stream().findFirst(); // System.out.println(answerSet); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java index 62ba483dd..4884832c2 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java @@ -113,7 +113,7 @@ public void runTest(String aspString, Consumer programVerifier, LOGGER.debug("Testing ASP String {}", aspString); // Parse and pre-evaluate program // Alpha instance with default config, stratified evaluation enabled - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = new AlphaFactory().newAlpha(); InputProgram input = alpha.readProgramString(aspString); DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(input); NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java index 7a5e06633..4d5823aa1 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java @@ -39,7 +39,6 @@ private static List buildConfigs() { String[] gtcValues = new String[]{DEFAULT_GROUNDER_TOLERANCE, "permissive" }; String grounderToleranceRules = DEFAULT_GROUNDER_TOLERANCE; boolean[] grounderAccumulatorValues = ci ? new boolean[]{DEFAULT_DISABLE_INSTANCE_REMOVAL, true } : new boolean[]{DEFAULT_DISABLE_INSTANCE_REMOVAL }; - boolean[] evaluateStratifiedValues = new boolean[]{false, true }; boolean[] enableDebugChecksValues = new boolean[]{DEFAULT_ENABLE_DEBUG_CHECKS, true }; //@formatter:on @@ -58,21 +57,18 @@ private static List buildConfigs() { for (String branchingHeuristicName : heuristics) { for (String grounderToleranceConstraints : gtcValues) { for (boolean grounderAccumulatorEnabled : grounderAccumulatorValues) { - for (boolean evaluateStratified : evaluateStratifiedValues) { - for (boolean enableDebugChecks : enableDebugChecksValues) { - SystemConfig cfg = new SystemConfig(); - cfg.setSolverName(solverName); - cfg.setNogoodStoreName(nogoodStoreName); - cfg.setBranchingHeuristicName(branchingHeuristicName); - cfg.setGrounderToleranceRules(grounderToleranceRules); - cfg.setGrounderToleranceConstraints(grounderToleranceConstraints); - cfg.setGrounderAccumulatorEnabled(grounderAccumulatorEnabled); - cfg.setEvaluateStratifiedPart(evaluateStratified); - cfg.setDebugInternalChecks(enableDebugChecks); - cfg.setSeed(seed); - - configsToTest.add(cfg); - } + for (boolean enableDebugChecks : enableDebugChecksValues) { + SystemConfig cfg = new SystemConfig(); + cfg.setSolverName(solverName); + cfg.setNogoodStoreName(nogoodStoreName); + cfg.setBranchingHeuristicName(branchingHeuristicName); + cfg.setGrounderToleranceRules(grounderToleranceRules); + cfg.setGrounderToleranceConstraints(grounderToleranceConstraints); + cfg.setGrounderAccumulatorEnabled(grounderAccumulatorEnabled); + cfg.setDebugInternalChecks(enableDebugChecks); + cfg.setSeed(seed); + + configsToTest.add(cfg); } } } @@ -92,40 +88,34 @@ private static List buildConfigs() { */ private static List buildConfigsForAggregateTests() { List configsToTest = new ArrayList<>(); - - boolean[] evaluateStratifiedValues = new boolean[] {true, false }; boolean[] useSortingGridValues = new boolean[] {true, false }; boolean[] supportNegativeSumElementsValues = new boolean[] {true, false }; - for (boolean evalStratified : evaluateStratifiedValues) { - for (boolean useSortingGrid : useSortingGridValues) { - for (boolean supportNegativeElements : supportNegativeSumElementsValues) { - // new RegressionTestConfig( - // DEFAULT_SOLVER_NAME, DEFAULT_GROUNDER_NAME, DEFAULT_NOGOOD_STORE, Heuristic.valueOf(DEFAULT_BRANCHING_HEURISTIC), - // 0, DEFAULT_ENABLE_DEBUG_CHECKS, DEFAULT_GROUNDER_TOLERANCE, DEFAULT_GROUNDER_TOLERANCE, DEFAULT_DISABLE_INSTANCE_REMOVAL, - // evalStratified, - // useSortingGrid, supportNegativeElements)); - AggregateRewritingConfig aggCfg = new AggregateRewritingConfig(); - aggCfg.setUseSortingGridEncoding(useSortingGrid); - aggCfg.setSupportNegativeValuesInSums(supportNegativeElements); - - SystemConfig cfg = new SystemConfig(); - cfg.setSolverName(DEFAULT_SOLVER_NAME); - cfg.setNogoodStoreName(DEFAULT_NOGOOD_STORE); - cfg.setBranchingHeuristicName(DEFAULT_BRANCHING_HEURISTIC); - cfg.setSeed(0); - cfg.setDebugInternalChecks(DEFAULT_ENABLE_DEBUG_CHECKS); - cfg.setGrounderToleranceRules(DEFAULT_GROUNDER_TOLERANCE); - cfg.setGrounderToleranceConstraints(DEFAULT_GROUNDER_TOLERANCE); - cfg.setGrounderAccumulatorEnabled(DEFAULT_DISABLE_INSTANCE_REMOVAL); - cfg.setEvaluateStratifiedPart(evalStratified); - cfg.setAggregateRewritingConfig(aggCfg); - - configsToTest.add(cfg); - } + for (boolean useSortingGrid : useSortingGridValues) { + for (boolean supportNegativeElements : supportNegativeSumElementsValues) { + // new RegressionTestConfig( + // DEFAULT_SOLVER_NAME, DEFAULT_GROUNDER_NAME, DEFAULT_NOGOOD_STORE, Heuristic.valueOf(DEFAULT_BRANCHING_HEURISTIC), + // 0, DEFAULT_ENABLE_DEBUG_CHECKS, DEFAULT_GROUNDER_TOLERANCE, DEFAULT_GROUNDER_TOLERANCE, DEFAULT_DISABLE_INSTANCE_REMOVAL, + // evalStratified, + // useSortingGrid, supportNegativeElements)); + AggregateRewritingConfig aggCfg = new AggregateRewritingConfig(); + aggCfg.setUseSortingGridEncoding(useSortingGrid); + aggCfg.setSupportNegativeValuesInSums(supportNegativeElements); + + SystemConfig cfg = new SystemConfig(); + cfg.setSolverName(DEFAULT_SOLVER_NAME); + cfg.setNogoodStoreName(DEFAULT_NOGOOD_STORE); + cfg.setBranchingHeuristicName(DEFAULT_BRANCHING_HEURISTIC); + cfg.setSeed(0); + cfg.setDebugInternalChecks(DEFAULT_ENABLE_DEBUG_CHECKS); + cfg.setGrounderToleranceRules(DEFAULT_GROUNDER_TOLERANCE); + cfg.setGrounderToleranceConstraints(DEFAULT_GROUNDER_TOLERANCE); + cfg.setGrounderAccumulatorEnabled(DEFAULT_DISABLE_INSTANCE_REMOVAL); + cfg.setAggregateRewritingConfig(aggCfg); + + configsToTest.add(cfg); } } - return configsToTest; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java index 4e7f4e831..686df4990 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java @@ -32,30 +32,30 @@ public static void runWithTimeout(SystemConfig cfg, long baseTimeout, long timeo } public static Solver buildSolverForRegressionTest(String programString, SystemConfig cfg) { - Alpha alpha = AlphaFactory.newAlpha(cfg); + Alpha alpha = new AlphaFactory().newAlpha(cfg); InputProgram program = alpha.readProgramString(programString); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } public static Solver buildSolverForRegressionTest(InputProgram program, SystemConfig cfg) { - Alpha alpha = AlphaFactory.newAlpha(cfg); + Alpha alpha = new AlphaFactory().newAlpha(cfg); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } public static Set collectRegressionTestAnswerSets(String program, SystemConfig cfg) { - Alpha alpha = AlphaFactory.newAlpha(cfg); + Alpha alpha = new AlphaFactory().newAlpha(cfg); InputProgram in = alpha.readProgramString(program); return alpha.solve(in).collect(Collectors.toSet()); } public static Set collectRegressionTestAnswerSets(InputProgram program, SystemConfig cfg) { - return AlphaFactory.newAlpha(cfg) + return new AlphaFactory().newAlpha(cfg) .solve(program) .collect(Collectors.toSet()); } private static Set solveForConfig(String programString, SystemConfig cfg) { - Alpha alpha = AlphaFactory.newAlpha(cfg); + Alpha alpha = new AlphaFactory().newAlpha(cfg); InputProgram program = alpha.readProgramString(programString); return alpha.solve(program).collect(Collectors.toSet()); } @@ -80,8 +80,4 @@ public static void ignoreTestForNonDefaultDomainIndependentHeuristics(SystemConf Assumptions.assumeTrue(cfg.getBranchingHeuristic() == Heuristic.VSIDS); } - public static void ignoreTestForStratifiedEvaluationDisabled(SystemConfig cfg) { - Assumptions.assumeTrue(cfg.isEvaluateStratifiedPart()); - } - } From 491390f4cc6c52f386180ad224e391f83f5f2967 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 5 Sep 2022 17:31:35 +0200 Subject: [PATCH 37/96] fix mock implementation for actions --- .../AbstractActionImplementationProvider.java | 20 ++++++++-------- .../MockActionImplementationProvider.java | 13 ++++------- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 12 +++------- .../test/util/MockedActionsAlphaFactory.java | 23 +++++++++++++++++++ .../alpha.java-common-conventions.gradle.kts | 1 + 5 files changed, 43 insertions(+), 26 deletions(-) create mode 100644 alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java index cda9a2eea..6079adabe 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java @@ -23,11 +23,8 @@ public abstract class AbstractActionImplementationProvider implements ActionImpl private final IntIdGenerator idGenerator = new IntIdGenerator(); private final Map supportedActions = new HashMap<>(); - private final ConstantTerm stdout = Terms.newConstant( - new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())); - private final ConstantTerm stdin = Terms.newConstant( - new InputStreamHandle(idGenerator.getNextId(), - new BufferedReader(new InputStreamReader(getStdinStream())))); + private ConstantTerm stdoutHandle; + private ConstantTerm stdinHandle; public AbstractActionImplementationProvider() { registerAction("fileOutputStream", this::openFileOutputStreamAction); @@ -49,13 +46,15 @@ public final Map getSupportedActions() { * Returns a predicate interpretation specifying an external that takes no arguments * and returns a reference to the standard system output stream (stdout). */ - // TODO we need to reuse this term! (do we?? its interned...) public final PredicateInterpretation getStdoutTerm() { + if (stdoutHandle == null) { + stdoutHandle = Terms.newConstant(new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())); + } return (trms) -> { if (!trms.isEmpty()) { throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); } - return Collections.singleton(Collections.singletonList(stdout)); + return Collections.singleton(Collections.singletonList(stdoutHandle)); }; } @@ -63,13 +62,16 @@ public final PredicateInterpretation getStdoutTerm() { * Returns a predicate interpretation specifying an external that takes no arguments * and returns a reference to the standard system input stream (stdin). */ - // TODO we need to reuse this term! (do we?? its interned...) public final PredicateInterpretation getStdinTerm() { + if (stdinHandle == null) { + stdinHandle = Terms.newConstant(new InputStreamHandle(idGenerator.getNextId(), + new BufferedReader(new InputStreamReader(getStdinStream())))); + } return (trms) -> { if (!trms.isEmpty()) { throw new IllegalArgumentException("Invalid method call! Expected term list to be empty!"); } - return Collections.singleton(Collections.singletonList(stdin)); + return Collections.singleton(Collections.singletonList(stdinHandle)); }; } diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java index a31173162..05ea46116 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -1,12 +1,12 @@ package at.ac.tuwien.kr.alpha.test; -import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.Map; +import org.apache.commons.io.IOUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -17,12 +17,13 @@ public class MockActionImplementationProvider extends AbstractActionImplementati @SuppressWarnings("unused") private static final Logger LOGGER = LoggerFactory.getLogger(MockActionImplementationProvider.class); - private ByteArrayOutputStream stdoutMock = new ByteArrayOutputStream(); - private ByteArrayInputStream stdinMock; + private final ByteArrayOutputStream stdoutMock = new ByteArrayOutputStream(); + private final InputStream stdinMock; private Map mockedFileOutputs; private Map mockedFileInputs; - public MockActionImplementationProvider() { + public MockActionImplementationProvider(String inputBuffer) { + stdinMock = IOUtils.toInputStream(inputBuffer, "UTF-8"); } @Override @@ -38,10 +39,6 @@ public void resetStdoutContent() { stdoutMock.reset(); } - public void setMockInput(String input) { - stdinMock = new ByteArrayInputStream(input.getBytes()); - } - public void setMockedFileOutputs(Map mockedFileOutputs) { this.mockedFileOutputs = mockedFileOutputs; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index f0a25b778..c17e9dddc 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,15 +1,11 @@ package at.ac.tuwien.kr.alpha; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; -import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionServiceImpl; -import at.ac.tuwien.kr.alpha.test.MockActionImplementationProvider; +import at.ac.tuwien.kr.alpha.test.util.MockedActionsAlphaFactory; /** * End-to-end tests covering Evolog action support. @@ -24,11 +20,9 @@ public class ActionsTest { * Simple smoke test which verifies correct behavior of an Evolog "Hello World" program. */ @Test - @Disabled // TODO we need to pass stdin/stdout externals into parser public void helloWorld() { - MockActionImplementationProvider actionMock = new MockActionImplementationProvider(); - ActionExecutionService actionService = new ActionExecutionServiceImpl(actionMock); - Alpha alpha = new AlphaFactory().newAlpha(new SystemConfig()); + MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); + Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); // TODO check mock for correct output content diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java new file mode 100644 index 000000000..82d6863d0 --- /dev/null +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java @@ -0,0 +1,23 @@ +package at.ac.tuwien.kr.alpha.test.util; + +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; +import at.ac.tuwien.kr.alpha.test.MockActionImplementationProvider; + +public class MockedActionsAlphaFactory extends AlphaFactory { + + private MockActionImplementationProvider actionImplementationMock = new MockActionImplementationProvider(""); + + public MockActionImplementationProvider getActionImplementationMock() { + return actionImplementationMock; + } + + public void setActionImplementationMock(MockActionImplementationProvider actionImplementationMock) { + this.actionImplementationMock = actionImplementationMock; + } + + protected ActionImplementationProvider newActionImplementationProvider() { + return actionImplementationMock; + } + +} diff --git a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts index 1ccb2d408..423ce31ff 100644 --- a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts @@ -38,6 +38,7 @@ dependencies { testFixturesApi(jupiter("api")) testFixturesApi("org.slf4j:slf4j-api:1.7.32") + testFixturesImplementation("commons-io:commons-io:2.11.0") } // JUnit 5 From efd96e879fd2efe4605513886514f3f11c8c677e Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 6 Sep 2022 13:22:54 +0200 Subject: [PATCH 38/96] fix evolog hello world test --- .../AbstractActionImplementationProvider.java | 3 ++ .../at/ac/tuwien/kr/alpha/ActionsTest.java | 30 +++++++++++++++++-- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java index 6079adabe..22707f3ed 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java @@ -38,6 +38,7 @@ public AbstractActionImplementationProvider() { /** * Returns a map of all actions supported by this implementation provider. */ + @Override public final Map getSupportedActions() { return supportedActions; } @@ -46,6 +47,7 @@ public final Map getSupportedActions() { * Returns a predicate interpretation specifying an external that takes no arguments * and returns a reference to the standard system output stream (stdout). */ + @Override public final PredicateInterpretation getStdoutTerm() { if (stdoutHandle == null) { stdoutHandle = Terms.newConstant(new OutputStreamHandle(idGenerator.getNextId(), getStdoutStream())); @@ -62,6 +64,7 @@ public final PredicateInterpretation getStdoutTerm() { * Returns a predicate interpretation specifying an external that takes no arguments * and returns a reference to the standard system input stream (stdin). */ + @Override public final PredicateInterpretation getStdinTerm() { if (stdinHandle == null) { stdinHandle = Terms.newConstant(new InputStreamHandle(idGenerator.getNextId(), diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index c17e9dddc..694495ba7 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,8 +1,15 @@ package at.ac.tuwien.kr.alpha; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.List; +import java.util.stream.Collectors; + +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.test.util.MockedActionsAlphaFactory; @@ -14,9 +21,15 @@ public class ActionsTest { private static final String HELLO_WORLD = - "hello_result(RES) : @streamWrite[STDOUT, \" World!\"] = RES :- &stdout(STDOUT)."; + "hello_result(RES) : @streamWrite[STDOUT, \"Hello World!\"] = RES :- &stdout(STDOUT)."; - /** + private static final String WRITE_TO_FILE = + "outfile(\"dummy.file\")." + + "outfile_open_result(F, R) : @fileOutputStream[F] = R :- outfile(F)." + + "outfile_write_result(F, R) : @streamWrite[HD, \"Foo bar!\"] = R :- outfile_open_result(F, success(stream(HD)))." + + "outfile_close_result(F, R) : @outputStreamClose[HD] = R :- outfile_open_result(F, success(stream(HD))), outfile_write_result(F, success(ok))."; + + /** * Simple smoke test which verifies correct behavior of an Evolog "Hello World" program. */ @Test @@ -25,7 +38,18 @@ public void helloWorld() { Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); - // TODO check mock for correct output content + assertEquals("Hello World!", alphaFactory.getActionImplementationMock().getStdoutContent()); + } + + @Test + @Disabled // TODO we need to add our destination file in the mock! + public void writeToFile() { + MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); + Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); + InputProgram program = alpha.readProgramString(WRITE_TO_FILE); + List answerSets = alpha.solve(program).collect(Collectors.toList()); + // TODO check answer set + // TODO check invocation counts } } From 8312dcf9d457a83d0e2c143342bb3adb4558c2ec Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 3 Oct 2022 20:30:09 +0200 Subject: [PATCH 39/96] fix name generation for stream handles --- .../alpha/core/actions/InputStreamHandle.java | 2 +- .../core/actions/OutputStreamHandle.java | 2 +- .../MockActionImplementationProvider.java | 8 ++++ .../at/ac/tuwien/kr/alpha/ActionsTest.java | 42 ++++++++++++------- 4 files changed, 37 insertions(+), 17 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java index 3064ec249..9692e555b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/InputStreamHandle.java @@ -22,7 +22,7 @@ public BufferedReader getStream() { @Override public String toString() { - return "inputStream-" + id; + return "inputStream_" + id; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java index edbb19184..e6d0d6e92 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/OutputStreamHandle.java @@ -23,7 +23,7 @@ public OutputStream getStream() { @Override public String toString() { - return "outputStream-" + id; + return "outputStream_" + id; } @Override diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java index 05ea46116..d830b6831 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -47,6 +47,14 @@ public void setMockedFileInputs(Map mockedFileInputs) { this.mockedFileInputs = mockedFileInputs; } + public Map getMockedFileOutputs() { + return mockedFileOutputs; + } + + public Map getMockedFileInputs() { + return mockedFileInputs; + } + @Override protected InputStream getStdinStream() { return stdinMock; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 694495ba7..4ee979f52 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,12 +1,18 @@ package at.ac.tuwien.kr.alpha; import static org.junit.jupiter.api.Assertions.assertEquals; +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; -import java.util.List; +import java.io.ByteArrayOutputStream; +import java.io.OutputStream; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; @@ -16,20 +22,19 @@ /** * End-to-end tests covering Evolog action support. - * Note that all tests in this suite depend on stratified evaluation being enabled. */ public class ActionsTest { - private static final String HELLO_WORLD = - "hello_result(RES) : @streamWrite[STDOUT, \"Hello World!\"] = RES :- &stdout(STDOUT)."; + private static final Logger LOGGER = LoggerFactory.getLogger(ActionsTest.class); - private static final String WRITE_TO_FILE = - "outfile(\"dummy.file\")." - + "outfile_open_result(F, R) : @fileOutputStream[F] = R :- outfile(F)." - + "outfile_write_result(F, R) : @streamWrite[HD, \"Foo bar!\"] = R :- outfile_open_result(F, success(stream(HD)))." - + "outfile_close_result(F, R) : @outputStreamClose[HD] = R :- outfile_open_result(F, success(stream(HD))), outfile_write_result(F, success(ok))."; + private static final String HELLO_WORLD = "hello_result(RES) : @streamWrite[STDOUT, \"Hello World!\"] = RES :- &stdout(STDOUT)."; - /** + private static final String WRITE_TO_FILE = "outfile(\"dummy.file\")." + + "outfile_open_result(F, R) : @fileOutputStream[F] = R :- outfile(F)." + + "outfile_write_result(F, R) : @streamWrite[HD, \"Foo bar!\"] = R :- outfile_open_result(F, success(stream(HD)))." + + "outfile_close_result(F, R) : @outputStreamClose[HD] = R :- outfile_open_result(F, success(stream(HD))), outfile_write_result(F, success(ok))."; + + /** * Simple smoke test which verifies correct behavior of an Evolog "Hello World" program. */ @Test @@ -42,14 +47,21 @@ public void helloWorld() { } @Test - @Disabled // TODO we need to add our destination file in the mock! public void writeToFile() { + Map mockedFileOutputs = new HashMap<>(); + ByteArrayOutputStream dummyFileContent = new ByteArrayOutputStream(); + mockedFileOutputs.put("dummy.file", dummyFileContent); MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); + alphaFactory.getActionImplementationMock().setMockedFileOutputs(mockedFileOutputs); Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); InputProgram program = alpha.readProgramString(WRITE_TO_FILE); - List answerSets = alpha.solve(program).collect(Collectors.toList()); - // TODO check answer set - // TODO check invocation counts + Set answerSets = alpha.solve(program).collect(Collectors.toSet()); + LOGGER.debug("Got answer sets: {}", answerSets); + assertAnswerSetsEqual( + "outfile(\"dummy.file\"), outfile_open_result(\"dummy.file\", success(stream(outputStream_2)))," + + " outfile_write_result(\"dummy.file\", success(ok)), outfile_close_result(\"dummy.file\", success(ok))", + answerSets); + assertEquals("Foo bar!", dummyFileContent.toString()); } } From db5544fadb92f0317dbe406d0adc862abf1a5b6f Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 10:14:37 +0200 Subject: [PATCH 40/96] unit tests for actions --- .../src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 4ee979f52..37c49a1ba 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -10,6 +10,7 @@ import java.util.Set; import java.util.stream.Collectors; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,6 +48,7 @@ public void helloWorld() { } @Test + @Disabled public void writeToFile() { Map mockedFileOutputs = new HashMap<>(); ByteArrayOutputStream dummyFileContent = new ByteArrayOutputStream(); @@ -59,7 +61,7 @@ public void writeToFile() { LOGGER.debug("Got answer sets: {}", answerSets); assertAnswerSetsEqual( "outfile(\"dummy.file\"), outfile_open_result(\"dummy.file\", success(stream(outputStream_2)))," - + " outfile_write_result(\"dummy.file\", success(ok)), outfile_close_result(\"dummy.file\", success(ok))", + + " outfile_write_result(\"dummy.file\", success(ok)), outfile_close_result(\"dummy.file\", success(ok))", answerSets); assertEquals("Foo bar!", dummyFileContent.toString()); } From ac6d27f34cbdbfe9cafc885e1d9d62053d1a7333 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 12:58:56 +0200 Subject: [PATCH 41/96] reify inline directives, move rule implementations to commons --- .../tuwien/kr/alpha/api/rules/NormalRule.java | 4 +- .../{ReificationHelper.java => Reifier.java} | 31 ++++++--- .../kr/alpha/commons}/rules/AbstractRule.java | 4 +- .../kr/alpha/commons}/rules/BasicRule.java | 9 +-- .../alpha/commons/rules/NormalRuleImpl.java | 21 ++++++ .../tuwien/kr/alpha/commons/rules/Rules.java | 57 ++++++++-------- ...cationHelperTest.java => ReifierTest.java} | 41 ++++++----- .../alpha/core/parser/ParseTreeVisitor.java | 14 ++-- .../alpha/core/programs/InternalProgram.java | 4 +- .../core/programs/NormalProgramImpl.java | 4 +- .../ArithmeticTermsRewriting.java | 15 ++-- .../transformation/ChoiceHeadToNormal.java | 6 +- .../transformation/EnumerationRewriting.java | 4 +- .../IntervalTermToIntervalAtom.java | 4 +- .../transformation/PredicateInternalizer.java | 4 +- .../VariableEqualityRemoval.java | 4 +- .../aggregates/AggregateLiteralSplitting.java | 4 +- .../AggregateOperatorNormalization.java | 4 +- .../aggregates/AggregateRewriting.java | 4 +- .../encoders/AbstractAggregateEncoder.java | 4 +- .../aggregates/encoders/MinMaxEncoder.java | 6 +- .../StringtemplateBasedAggregateEncoder.java | 6 +- .../kr/alpha/core/rules/InternalRule.java | 16 ++++- .../tuwien/kr/alpha/core/common/RuleTest.java | 6 +- .../alpha/core/grounder/ChoiceGrounder.java | 68 +++++++++---------- .../kr/alpha/core/grounder/DummyGrounder.java | 9 +-- .../alpha/core/grounder/RuleToStringTest.java | 5 +- .../alpha/core/grounder/SubstitutionTest.java | 6 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 4 +- .../kr/alpha/api/impl/AlphaImplTest.java | 2 +- 30 files changed, 213 insertions(+), 157 deletions(-) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/{ReificationHelper.java => Reifier.java} (96%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/rules/AbstractRule.java (98%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/rules/BasicRule.java (82%) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java (52%) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/{ReificationHelperTest.java => ReifierTest.java} (90%) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java index 5a5c995c6..60aabfc42 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java @@ -10,6 +10,8 @@ */ public interface NormalRule extends Rule { - BasicAtom getHeadAtom(); + default BasicAtom getHeadAtom() { + return this.isConstraint() ? null : this.getHead().getAtom(); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java similarity index 96% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index 240ec89a8..2d1e729c6 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelper.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -8,6 +8,7 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; @@ -32,7 +33,7 @@ import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -public class ReificationHelper { +public class Reifier { // Predicates describing rules. static final Predicate RULE = Predicates.getPredicate("rule", 1); @@ -120,6 +121,9 @@ public class ReificationHelper { static final Predicate FUNCTION_TERM_NUM_ARGUMENTS = Predicates.getPredicate("functionTerm_numArguments", 2); static final Predicate FUNCTION_TERM_ARGUMENT = Predicates.getPredicate("functionTerm_argumentTerm", 3); + // Predicates describing InlineDirectives + static final Predicate INLINE_DIRECTIVE = Predicates.getPredicate("inlineDirective", 2); + // Constants describing head types. static final ConstantTerm HEAD_TYPE_NORMAL = Terms.newSymbolicConstant("normal"); static final ConstantTerm HEAD_TYPE_CHOICE = Terms.newSymbolicConstant("choice"); @@ -179,24 +183,24 @@ public class ReificationHelper { private final Map> reifiedPredicates = new HashMap<>(); - public ReificationHelper(Supplier> idProvider) { + public Reifier(Supplier> idProvider) { this.idProvider = idProvider; } public Set reifyProgram(ASPCore2Program program) { - // TODO reify directives Set reified = new LinkedHashSet<>(); + reified.addAll(reifyDirectives(program.getInlineDirectives())); + for (Atom fact : program.getFacts()) { + ConstantTerm factId = idProvider.get(); + reified.add(Atoms.newBasicAtom(FACT, factId)); + reified.addAll(reifyAtom(factId, fact)); + } for (Rule rule : program.getRules()) { if (rule.isConstraint()) { continue; } reified.addAll(reifyRule(rule)); } - for (Atom fact : program.getFacts()) { - ConstantTerm factId = idProvider.get(); - reified.add(Atoms.newBasicAtom(FACT, factId)); - reified.addAll(reifyAtom(factId, fact)); - } for (Map.Entry> entry : reifiedPredicates.entrySet()) { reified.add(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), Terms.newConstant(entry.getKey().getArity()))); @@ -204,6 +208,17 @@ public Set reifyProgram(ASPCore2Program program) { return reified; } + /** + * Generates atoms of form inlineDirective("", ""). + */ + Set reifyDirectives(InlineDirectives directives) { + Set reified = new LinkedHashSet<>(); + for (Map.Entry entry : directives.getDirectives().entrySet()) { + reified.add(Atoms.newBasicAtom(INLINE_DIRECTIVE, Terms.newConstant(entry.getKey().name()), Terms.newConstant(entry.getValue()))); + } + return reified; + } + Set reifyRule(Rule rule) { Set reified = new LinkedHashSet<>(); ConstantTerm ruleId = idProvider.get(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java similarity index 98% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java index 50d78db70..44f5800b1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; import java.util.Collections; import java.util.LinkedHashSet; @@ -55,7 +55,7 @@ public AbstractRule(H head, List body) { * * @return true if this rule is safe. */ - private boolean isSafe() { + boolean isSafe() { // TODO: do the real check. // Note that - once a proper safety check is implemented - that check should probably be specific for each rule // implementation, therefore this method should be "protected abstract" here and implemented in each subclass. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java similarity index 82% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java index 1a2cab45e..df1e8cd25 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java @@ -25,23 +25,20 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; /** * Represents a non-ground rule or a constraint. A {@link BasicRule} has a general {@link Head}, meaning both choice heads and disjunctive * heads are permissible. - * This implementation represents a rule after being parsed from a given ASP program, but before being transformed into a - * {@link NormalRuleImpl}. */ -public class BasicRule extends AbstractRule implements Rule { +class BasicRule extends AbstractRule { - public BasicRule(Head head, List body) { + BasicRule(Head head, List body) { super(head, body); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java new file mode 100644 index 000000000..4c0f5585a --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java @@ -0,0 +1,21 @@ +package at.ac.tuwien.kr.alpha.commons.rules; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; + +/** + * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. + * Currently, any constructs such as aggregates, intervals, etc. in the rule body are allowed. + * + * Copyright (c) 2019, the Alpha Team. + */ +class NormalRuleImpl extends AbstractRule implements NormalRule { + + NormalRuleImpl(NormalHead head, List body) { + super(head, body); + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java similarity index 52% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java index c75bdcbc9..0eda75344 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.commons.rules; import java.util.ArrayList; import java.util.List; @@ -12,19 +12,37 @@ import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.util.Util; -/** - * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. - * Currently, any constructs such as aggregates, intervals, etc. in the rule body are allowed. - * - * Copyright (c) 2019, the Alpha Team. - */ -public class NormalRuleImpl extends AbstractRule implements NormalRule { +public final class Rules { - public NormalRuleImpl(NormalHead head, List body) { - super(head, body); + private Rules() { + throw new AssertionError("Cannot instantiate utility class!"); } - public static NormalRuleImpl fromBasicRule(Rule rule) { + public static Rule newRule(Head head, List body) { + return new BasicRule(head, body); + } + + public static Rule newRule(Head head, Literal... body) { + List bodyLst = new ArrayList<>(); + for (Literal lit : body) { + bodyLst.add(lit); + } + return new BasicRule(head, bodyLst); + } + + public static NormalRule newNormalRule(NormalHead head, List body) { + return new NormalRuleImpl(head, body); + } + + public static NormalRule newNormalRule(NormalHead head, Literal... body) { + List bodyLst = new ArrayList<>(); + for (Literal lit : body) { + bodyLst.add(lit); + } + return new NormalRuleImpl(head, bodyLst); + } + + public static NormalRule toNormalRule(Rule rule) { BasicAtom headAtom = null; if (!rule.isConstraint()) { if (!(rule.getHead() instanceof NormalHead)) { @@ -35,21 +53,4 @@ public static NormalRuleImpl fromBasicRule(Rule rule) { return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new ArrayList<>(rule.getBody())); } - public boolean isGround() { - if (!isConstraint() && !this.getHead().isGround()) { - return false; - } - for (Literal bodyElement : this.getBody()) { - if (!bodyElement.isGround()) { - return false; - } - } - return true; - } - - @Override - public BasicAtom getHeadAtom() { - return this.isConstraint() ? null : this.getHead().getAtom(); - } - } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java similarity index 90% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java index 018c62e8b..35af2717c 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReificationHelperTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java @@ -32,7 +32,7 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; -public class ReificationHelperTest { +public class ReifierTest { private Supplier> newIdGenerator() { return new Supplier>() { @@ -52,7 +52,7 @@ public void reifySymbolicConstant() { ConstantTerm constant = Terms.newSymbolicConstant("someConstant"); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("symbol")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someConstant")))); @@ -63,7 +63,7 @@ public void reifyStringConstant() { ConstantTerm constant = Terms.newConstant("someString"); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someString")))); @@ -74,7 +74,7 @@ public void reifyStringWithQuotes() { ConstantTerm constant = Terms.newConstant("someStringWith\"Quotes\""); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someStringWith\\\"Quotes\\\"")))); @@ -86,7 +86,7 @@ public void reifyIntegerConstant() { ConstantTerm constant = Terms.newConstant(666); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyConstantTerm(reifiedId, constant); + Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("integer")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant(Integer.toString(666))))); @@ -97,7 +97,7 @@ public void reifyVariable() { VariableTerm var = Terms.newVariable("SOME_VAR"); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyVariableTerm(reifiedId, var); + Set reified = new Reifier(idGen).reifyVariableTerm(reifiedId, var); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("variable")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("variableTerm_symbol", 2), reifiedId, Terms.newConstant("SOME_VAR")))); } @@ -107,7 +107,7 @@ public void reifyArithmeticTerm() { Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyArithmeticTerm(reifiedId, (ArithmeticTerm) arithmeticTerm); + Set reified = new Reifier(idGen).reifyArithmeticTerm(reifiedId, (ArithmeticTerm) arithmeticTerm); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("arithmetic")))); assertTrue(reified.contains( Atoms.newBasicAtom(Predicates.getPredicate("arithmeticTerm_operator", 2), reifiedId, Terms.newConstant(ArithmeticOperator.PLUS.toString())))); @@ -126,7 +126,7 @@ public void reifyFunctionTerm() { FunctionTerm funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyFunctionTerm(reifiedId, funcTerm); + Set reified = new Reifier(idGen).reifyFunctionTerm(reifiedId, funcTerm); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("function")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_symbol", 2), reifiedId, Terms.newConstant("f")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_numArguments", 2), reifiedId, Terms.newConstant(1)))); @@ -143,7 +143,7 @@ public void reifyTerm() { Term funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); Supplier> idGen = newIdGenerator(); - ReificationHelper reificationHelper = new ReificationHelper(idGen); + Reifier reificationHelper = new Reifier(idGen); ConstantTerm constId = idGen.get(); Set reifiedConst = reificationHelper.reifyTerm(constId, constTerm); @@ -167,7 +167,7 @@ public void reifyBasicAtom() { BasicAtom atom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyBasicAtom(reifiedId, atom); + Set reified = new Reifier(idGen).reifyBasicAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("basic")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("basicAtom_numTerms", 2), reifiedId, Terms.newConstant(2)))); assertEquals(2, @@ -183,7 +183,7 @@ public void reifyComparisonAtom() { ComparisonAtom atom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyComparisonAtom(reifiedId, atom); + Set reified = new Reifier(idGen).reifyComparisonAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("comparison")))); assertEquals(1, reified.stream() @@ -209,7 +209,7 @@ public void reifyAggregateElement() { AggregateElement element = Atoms.newAggregateElement(elementTerms, elementLiterals); Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyAggregateElement(reifiedId, element); + Set reified = new Reifier(idGen).reifyAggregateElement(reifiedId, element); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numTerms", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, reified.stream() @@ -247,7 +247,7 @@ public void reifyAggregateAtom() { Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyAggregateAtom(reifiedId, atom); + Set reified = new Reifier(idGen).reifyAggregateAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("aggregate")))); assertTrue(reified @@ -271,7 +271,7 @@ public void reifyExternalAtom() { Supplier> idGen = newIdGenerator(); ConstantTerm reifiedId = idGen.get(); - Set reified = new ReificationHelper(idGen).reifyExternalAtom(reifiedId, atom); + Set reified = new Reifier(idGen).reifyExternalAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("external")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("externalAtom_numInputTerms", 2), reifiedId, Terms.newConstant(1)))); @@ -326,20 +326,25 @@ public void reifyAtom() { Supplier> idGen = newIdGenerator(); ConstantTerm reifiedBasicAtomId = idGen.get(); - Set reifiedBasicAtom = new ReificationHelper(idGen).reifyAtom(reifiedBasicAtomId, basicAtom); + Set reifiedBasicAtom = new Reifier(idGen).reifyAtom(reifiedBasicAtomId, basicAtom); assertTrue(reifiedBasicAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedBasicAtomId, Terms.newSymbolicConstant("basic")))); ConstantTerm reifiedCmpAtomId = idGen.get(); - Set reifiedCmpAtom = new ReificationHelper(idGen).reifyAtom(reifiedCmpAtomId, cmpAtom); + Set reifiedCmpAtom = new Reifier(idGen).reifyAtom(reifiedCmpAtomId, cmpAtom); assertTrue(reifiedCmpAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedCmpAtomId, Terms.newSymbolicConstant("comparison")))); ConstantTerm reifiedAggAtomId = idGen.get(); - Set reifiedAggAtom = new ReificationHelper(idGen).reifyAtom(reifiedAggAtomId, aggAtom); + Set reifiedAggAtom = new Reifier(idGen).reifyAtom(reifiedAggAtomId, aggAtom); assertTrue(reifiedAggAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedAggAtomId, Terms.newSymbolicConstant("aggregate")))); ConstantTerm reifiedExtAtomId = idGen.get(); - Set reifiedExtAtom = new ReificationHelper(idGen).reifyAtom(reifiedExtAtomId, extAtom); + Set reifiedExtAtom = new Reifier(idGen).reifyAtom(reifiedExtAtomId, extAtom); assertTrue(reifiedExtAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedExtAtomId, Terms.newSymbolicConstant("external")))); } + @Test + public void reifyDirectives() { + // TODO + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 868222d85..4eecbefe8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -27,8 +27,6 @@ */ package at.ac.tuwien.kr.alpha.core.parser; -import static java.util.Collections.emptyList; - import java.util.ArrayList; import java.util.Collections; import java.util.LinkedList; @@ -69,12 +67,12 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Copyright (c) 2016-2018, the Alpha Team. @@ -185,7 +183,7 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { programBuilder.addFact(((NormalHead) head).getAtom()); } else { // Treat facts with choice or disjunction in the head like a rule. - programBuilder.addRule(new BasicRule(head, emptyList())); + programBuilder.addRule(Rules.newRule(head, Collections.emptyList())); } return null; } @@ -193,14 +191,14 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { @Override public Object visitStatement_constraint(ASPCore2Parser.Statement_constraintContext ctx) { // CONS body DOT - programBuilder.addRule(new BasicRule(null, visitBody(ctx.body()))); + programBuilder.addRule(Rules.newRule(null, visitBody(ctx.body()))); return null; } @Override public Object visitStatement_rule(ASPCore2Parser.Statement_ruleContext ctx) { // head CONS body DOT - programBuilder.addRule(new BasicRule(visitHead(ctx.head()), visitBody(ctx.body()))); + programBuilder.addRule(Rules.newRule(visitHead(ctx.head()), visitBody(ctx.body()))); return null; } @@ -302,7 +300,7 @@ public Object visitDirective_enumeration(ASPCore2Parser.Directive_enumerationCon public List visitBody(ASPCore2Parser.BodyContext ctx) { // body : ( naf_literal | aggregate ) (COMMA body)?; if (ctx == null) { - return emptyList(); + return Collections.emptyList(); } final List literals = new ArrayList<>(); @@ -479,7 +477,7 @@ public BasicAtom visitClassical_literal(ASPCore2Parser.Classical_literalContext public List visitTerms(ASPCore2Parser.TermsContext ctx) { // terms : term (COMMA terms)?; if (ctx == null) { - return emptyList(); + return Collections.emptyList(); } final List terms = new ArrayList<>(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index bca2f97cc..e166b081f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -15,11 +15,11 @@ import at.ac.tuwien.kr.alpha.api.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.grounder.FactIntervalEvaluator; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * A program in the internal representation needed for grounder and solver, i.e.: rules must have normal heads, all @@ -102,7 +102,7 @@ public Map getRulesById() { public NormalProgram toNormalProgram() { List normalRules = new ArrayList<>(); for (CompiledRule rule : getRules()) { - normalRules.add(new NormalRuleImpl(rule.getHead(), new ArrayList<>(rule.getBody()))); + normalRules.add(Rules.newNormalRule(rule.getHead(), new ArrayList<>(rule.getBody()))); } return new NormalProgramImpl(normalRules, getFacts(), getInlineDirectives()); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java index dc886e47a..458d6e41d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java @@ -10,7 +10,7 @@ import at.ac.tuwien.kr.alpha.api.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; /** * A program that only contains NormalRules. @@ -26,7 +26,7 @@ public NormalProgramImpl(List rules, List facts, InlineDirecti public static NormalProgramImpl fromInputProgram(ASPCore2Program inputProgram) { List normalRules = new ArrayList<>(); for (Rule r : inputProgram.getRules()) { - normalRules.add(NormalRuleImpl.fromBasicRule(r)); + normalRules.add(Rules.toNormalRule(r)); } return new NormalProgramImpl(normalRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index 259d410a9..fa1675a82 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -18,11 +18,11 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Transforms rules such that arithmetic terms only occur in comparison predicates. @@ -56,13 +56,14 @@ public NormalProgram apply(NormalProgram inputProgram) { } /** - * Takes a normal rule and rewrites it such that {@link ArithmeticTerm}s only appear inside {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}s. + * Takes a normal rule and rewrites it such that {@link ArithmeticTerm}s only appear inside + * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}s. * * @param inputProgramRule the rule to rewrite. * @return the rewritten rule. Note that a new {@link NormalRule} is returned for every call of this method. */ private NormalRule rewriteRule(NormalRule inputProgramRule) { - numArithmeticVariables = 0; // Reset number of introduced variables for each rule. + numArithmeticVariables = 0; // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; List rewrittenBodyLiterals = new ArrayList<>(); // Rewrite head. @@ -83,14 +84,16 @@ private NormalRule rewriteRule(NormalRule inputProgramRule) { } rewrittenBodyLiterals.add(rewriteAtom(literal.getAtom(), rewrittenBodyLiterals).toLiteral(!literal.isNegated())); } - return new NormalRuleImpl(rewrittenHead, rewrittenBodyLiterals); + return Rules.newNormalRule(rewrittenHead, rewrittenBodyLiterals); } /** - * Checks whether a normal rule contains an {@link ArithmeticTerm} outside of a {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * Checks whether a normal rule contains an {@link ArithmeticTerm} outside of a + * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. * * @param inputProgramRule the rule to check for presence of arithmetic terms outside comparison literals. - * @return true if the inputProgramRule contains an {@link ArithmeticTerm} outside of a {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * @return true if the inputProgramRule contains an {@link ArithmeticTerm} outside of a + * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. */ private boolean containsArithmeticTermsToRewrite(NormalRule inputProgramRule) { if (!inputProgramRule.isConstraint()) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 70da8e765..06ae095cd 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -43,10 +43,10 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Copyright (c) 2017-2021, the Alpha Team. @@ -105,11 +105,11 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { // Construct two guessing rules. List guessingRuleBodyWithNegHead = new ArrayList<>(ruleBody); guessingRuleBodyWithNegHead.add(Atoms.newBasicAtom(head.getPredicate(), head.getTerms()).toLiteral(false)); - additionalRules.add(new BasicRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead)); + additionalRules.add(Rules.newRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead)); List guessingRuleBodyWithHead = new ArrayList<>(ruleBody); guessingRuleBodyWithHead.add(Atoms.newBasicAtom(negPredicate, headTerms).toLiteral(false)); - additionalRules.add(new BasicRule(Heads.newNormalHead(head), guessingRuleBodyWithHead)); + additionalRules.add(Rules.newRule(Heads.newNormalHead(head), guessingRuleBodyWithHead)); // TODO: when cardinality constraints are possible, process the boundaries by adding a constraint with a cardinality check. } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index ca1c6a54a..eef4c6153 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -18,10 +18,10 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Rewrites the ordinary atom whose name is given in the input program by the enumeration directive #enum_atom_is into @@ -89,7 +89,7 @@ private List> rewriteRules(List> srcRules, Predicate enumP rewrittenLiterals.add(new EnumerationAtom(enumIdTerm, valueTerm, indexTerm).toLiteral()); } modifiedBodyLiterals.addAll(rewrittenLiterals); - rewrittenRules.add(new BasicRule(rule.getHead(), modifiedBodyLiterals)); + rewrittenRules.add(Rules.newRule(rule.getHead(), modifiedBodyLiterals)); } return rewrittenRules; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 013aaab5d..7503e3d23 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -44,11 +44,11 @@ import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.atoms.IntervalAtom; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Rewrites all interval terms in a rule into a new variable and an IntervalAtom. @@ -90,7 +90,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { for (Map.Entry interval : intervalReplacements.entrySet()) { rewrittenBody.add(new IntervalAtom(interval.getValue(), interval.getKey()).toLiteral()); } - return new NormalRuleImpl(rewrittenHead, rewrittenBody); + return Rules.newNormalRule(rewrittenHead, rewrittenBody); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 6a71a1092..86181b6ae 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -14,9 +14,9 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * @@ -69,7 +69,7 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String newBody.add(bodyElement); } } - return new BasicRule(newHead, newBody); + return Rules.newRule(newHead, newBody); } private static BasicAtom makePredicateInternal(BasicAtom atom) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 1e1ae53a3..d405a6bed 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -47,10 +47,10 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Removes variable equalities from rules by replacing one variable with the other. @@ -149,6 +149,6 @@ private Rule findAndReplaceVariableEquality(Rule rule) { headAtom.getTerms().set(i, replaced); } } - return new BasicRule(rewrittenHead, rewrittenBody); + return Rules.newRule(rewrittenHead, rewrittenBody); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java index 457d41daa..f781b6f86 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java @@ -14,7 +14,7 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; /** * Splits aggregate literals with both "lower" and "upper" bound operators into literals with only one operator each. @@ -86,7 +86,7 @@ private static List> splitAggregatesInRule(Rule sourceRule) { // Third, turn computed bodies into rules again. List> rewrittenRules = new ArrayList<>(); for (List rewrittenBody : rewrittenBodies) { - rewrittenRules.add(new BasicRule(sourceRule.getHead(), rewrittenBody)); + rewrittenRules.add(Rules.newRule(sourceRule.getHead(), rewrittenBody)); } return rewrittenRules; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java index 10625da60..51c3ae89d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java @@ -18,9 +18,9 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Transforms an {@link InputProgram} such that, for all aggregate (body-)literals, only the comparison operators "=" @@ -57,7 +57,7 @@ public static Rule normalize(Rule rule) { for (Literal lit : rule.getBody()) { rewrittenBody.addAll(rewriteLiteral(lit)); } - return new BasicRule(rule.getHead(), rewrittenBody); + return Rules.newRule(rule.getHead(), rewrittenBody); } private static List rewriteLiteral(Literal lit) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java index a810ee3db..f53c49113 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java @@ -16,6 +16,7 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -23,7 +24,6 @@ import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.CountEncoder; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.MinMaxEncoder; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.SumEncoder; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Rewrites {@link AggregateLiteral}s in programs to semantically equivalent, aggregate-free sub-programs. @@ -146,7 +146,7 @@ private static List> rewriteRulesWithAggregates(AggregateRewritingCon rewrittenBody.add(lit); } } - rewrittenRules.add(new BasicRule(rule.getHead(), rewrittenBody)); + rewrittenRules.add(Rules.newRule(rule.getHead(), rewrittenBody)); } return rewrittenRules; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index 1e257d30a..b2e32d02e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -19,13 +19,13 @@ import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.PredicateInternalizer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Abstract base class for aggregate encoders. An aggregate encoder provides an encoding for a given aggregate literal, @@ -104,7 +104,7 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { */ protected Rule encodeAggregateElement(AggregateInfo aggregateInfo, AggregateElement element) { BasicAtom headAtom = buildElementRuleHead(aggregateInfo.getId(), element, aggregateInfo.getAggregateArguments()); - return new BasicRule(Heads.newNormalHead(headAtom), + return Rules.newRule(Heads.newNormalHead(headAtom), ListUtils.union(element.getElementLiterals(), new ArrayList<>(aggregateInfo.getDependencies()))); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 8e007f78b..1af9a2711 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -16,6 +16,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; @@ -23,13 +25,13 @@ import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; public class MinMaxEncoder extends AbstractAggregateEncoder { @@ -119,7 +121,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) resultRuleBody.add(aggregateValueComparison); resultRuleBody.addAll(aggregateToEncode.getDependencies()); InputProgram.Builder bld = InputProgram.builder(parser.parse(encodingTemplate.render())); - BasicRule resultRule = new BasicRule(resultRuleHead, resultRuleBody); + Rule resultRule = Rules.newRule(resultRuleHead, resultRuleBody); bld.addRule(resultRule); return bld.build(); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index ad8a9c932..6b33ef17a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -16,6 +16,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; @@ -23,7 +24,6 @@ import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationRewriting; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; /** * Abstract base class for aggregate encoders making use of stringtemplates in their rewriting workflow. @@ -96,13 +96,13 @@ private String getBoundPredicateName(String aggregateId) { private Rule buildZeroBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), Terms.newConstant(0)); - return new BasicRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); } private Rule buildBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), aggregateToEncode.getLiteral().getAtom().getLowerBoundTerm()); - return new BasicRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java index 9a72fca12..ee2284f1d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java @@ -39,6 +39,7 @@ import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.rules.AbstractRule; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.commons.terms.Terms; @@ -49,7 +50,7 @@ * Represents a normal rule or a constraint for the semi-naive grounder. * A normal rule has no head atom if it represents a constraint, otherwise it has one atom in its head. */ -public class InternalRule extends NormalRuleImpl implements CompiledRule { +public class InternalRule extends AbstractRule implements CompiledRule { private static final IntIdGenerator ID_GENERATOR = new IntIdGenerator(); @@ -143,4 +144,17 @@ public int getRuleId() { return this.ruleId; } + @Override + public boolean isGround() { + if (!isConstraint() && !getHead().isGround()) { + return false; + } + for (Literal bodyElement : getBody()) { + if (!bodyElement.isGround()) { + return false; + } + } + return true; + } + } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java index 0c637cb1a..e54de4204 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java @@ -10,10 +10,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Copyright (c) 2018, the Alpha Team. @@ -26,10 +26,10 @@ public class RuleTest { public void renameVariables() { String originalRule = "p(X,Y) :- a, f(Z) = 1, q(X,g(Y),Z), dom(A)."; Rule rule = parser.parse(originalRule).getRules().get(0); - CompiledRule normalRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); + CompiledRule normalRule = InternalRule.fromNormalRule(Rules.toNormalRule(rule)); CompiledRule renamedRule = normalRule.renameVariables("_13"); Rule expectedRenamedRule = parser.parse("p(X_13, Y_13) :- a, f(Z_13) = 1, q(X_13, g(Y_13), Z_13), dom(A_13).").getRules().get(0); - CompiledRule expectedRenamedNormalRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(expectedRenamedRule)); + CompiledRule expectedRenamedNormalRule = InternalRule.fromNormalRule(Rules.toNormalRule(expectedRenamedRule)); assertEquals(expectedRenamedNormalRule.toString(), renamedRule.toString()); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java index 66374d312..7b34de18c 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java @@ -32,7 +32,6 @@ import static at.ac.tuwien.kr.alpha.core.common.NoGood.headFirst; import static at.ac.tuwien.kr.alpha.core.common.NoGoodTest.fromOldLiterals; import static java.util.Arrays.asList; -import static java.util.Collections.singleton; import java.util.Arrays; import java.util.Collections; @@ -51,10 +50,13 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom; @@ -63,22 +65,19 @@ import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** - * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. + * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. */ public class ChoiceGrounder implements Grounder { public static final Set EXPECTED = new HashSet<>(asList( - new AnswerSetBuilder() - .predicate("aa") - .build(), - new AnswerSetBuilder() - .predicate("bb") - .build() - )); + new AnswerSetBuilder() + .predicate("aa") + .build(), + new AnswerSetBuilder() + .predicate("bb") + .build())); private static final int ATOM_AA = 1; private static final int ATOM_BB = 2; @@ -94,32 +93,31 @@ public class ChoiceGrounder implements Grounder { private static final int BRULE_BB = 14; // { -_br2, -aa } private static final int CHOICE_EN_BR1 = 15; // { -_en_br1 } private static final int CHOICE_EN_BR2 = 16; // { -_en_br2 } - private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} + private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} private static final int CHOICE_DIS_BR2 = 18; // { -dis_br2, aa } private static final Map NOGOODS = Stream.of( - entry(RULE_AA, headFirst(fromOldLiterals(-ATOM_AA, ATOM_BR1))), - entry(BRULE_AA, headFirst(fromOldLiterals(-ATOM_BR1, -ATOM_BB))), - entry(RULE_BB, headFirst(fromOldLiterals(-ATOM_BB, ATOM_BR2))), - entry(BRULE_BB, headFirst(fromOldLiterals(-ATOM_BR2, -ATOM_AA))), - entry(CHOICE_EN_BR1, headFirst(fromOldLiterals(-ATOM_EN_BR1))), - entry(CHOICE_EN_BR2, headFirst(fromOldLiterals(-ATOM_EN_BR2))), - entry(CHOICE_DIS_BR1, headFirst(fromOldLiterals(-ATOM_DIS_BR1, ATOM_BB))), - entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA))) - ).collect(entriesToMap()); + entry(RULE_AA, headFirst(fromOldLiterals(-ATOM_AA, ATOM_BR1))), + entry(BRULE_AA, headFirst(fromOldLiterals(-ATOM_BR1, -ATOM_BB))), + entry(RULE_BB, headFirst(fromOldLiterals(-ATOM_BB, ATOM_BR2))), + entry(BRULE_BB, headFirst(fromOldLiterals(-ATOM_BR2, -ATOM_AA))), + entry(CHOICE_EN_BR1, headFirst(fromOldLiterals(-ATOM_EN_BR1))), + entry(CHOICE_EN_BR2, headFirst(fromOldLiterals(-ATOM_EN_BR2))), + entry(CHOICE_DIS_BR1, headFirst(fromOldLiterals(-ATOM_DIS_BR1, ATOM_BB))), + entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA)))).collect(entriesToMap()); private static final Map CHOICE_ENABLE = Stream.of( - entry(ATOM_BR1, ATOM_EN_BR1), - entry(ATOM_BR2, ATOM_EN_BR2) - ).collect(entriesToMap()); + entry(ATOM_BR1, ATOM_EN_BR1), + entry(ATOM_BR2, ATOM_EN_BR2)).collect(entriesToMap()); private static final Map CHOICE_DISABLE = Stream.of( - entry(ATOM_BR1, ATOM_DIS_BR1), - entry(ATOM_BR2, ATOM_DIS_BR2) - ).collect(entriesToMap()); + entry(ATOM_BR1, ATOM_DIS_BR1), + entry(ATOM_BR2, ATOM_DIS_BR2)).collect(entriesToMap()); private static BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); private static BasicAtom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)); - private static BasicRule ruleAA = new BasicRule(Heads.newNormalHead(atomAA), Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); - private static BasicRule ruleBB = new BasicRule(Heads.newNormalHead(atomBB), Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false))); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleAA)), new BasicSubstitution()); - private static Atom rule2 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleBB)), new BasicSubstitution()); + private static Rule ruleAA = Rules.newRule(Heads.newNormalHead(atomAA), + Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); + private static Rule ruleBB = Rules.newRule(Heads.newNormalHead(atomBB), + Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false))); + private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleAA)), new BasicSubstitution()); + private static Atom rule2 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleBB)), new BasicSubstitution()); private static Atom atomEnBR1 = ChoiceAtom.on(1); private static Atom atomEnBR2 = ChoiceAtom.on(2); private static Atom atomDisBR1 = ChoiceAtom.off(3); @@ -157,11 +155,11 @@ public AnswerSet assignmentToAnswerSet(Iterable trueAtoms) { Map> predicateInstances = new HashMap<>(); for (Predicate trueAtomPredicate : trueAtomPredicates) { BasicAtom basicAtom = Atoms.newBasicAtom(trueAtomPredicate); - predicateInstances.put(trueAtomPredicate, new TreeSet<>(singleton(basicAtom))); + predicateInstances.put(trueAtomPredicate, new TreeSet<>(Collections.singleton(basicAtom))); } // Note: This grounder only deals with 0-ary predicates, i.e., every atom is a predicate and there is - // only one predicate instance representing 0 terms. + // only one predicate instance representing 0 terms. return AnswerSets.newAnswerSet(trueAtomPredicates, predicateInstances); } @@ -174,7 +172,7 @@ public Map getNoGoods(Assignment assignment) { return new HashMap<>(); } } - + private boolean isFirst = true; @Override @@ -186,7 +184,7 @@ public Pair, Map> getChoiceAtoms() { return new ImmutablePair<>(new HashMap<>(), new HashMap<>()); } } - + @Override public Map> getHeadsToBodies() { return Collections.emptyMap(); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java index 669e6037f..c31821892 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java @@ -51,10 +51,13 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; @@ -62,9 +65,7 @@ import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Represents a small ASP program {@code { c :- a, b. a. b. }}. @@ -94,8 +95,8 @@ public class DummyGrounder implements Grounder { private static Atom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("a", 0)); private static Atom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("b", 0)); private static BasicAtom atomCC = Atoms.newBasicAtom(Predicates.getPredicate("c", 0)); - private static BasicRule ruleABC = new BasicRule(Heads.newNormalHead(atomCC), Arrays.asList(atomAA.toLiteral(), atomBB.toLiteral())); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(ruleABC)), new BasicSubstitution()); + private static Rule ruleABC = Rules.newRule(Heads.newNormalHead(atomCC), Arrays.asList(atomAA.toLiteral(), atomBB.toLiteral())); + private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleABC)), new BasicSubstitution()); private Set returnedNogoods = new HashSet<>(); public DummyGrounder(AtomStore atomStore) { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java index 38f8db22a..425511cc1 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java @@ -35,11 +35,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.rules.Rule; import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; /** * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. @@ -93,7 +92,7 @@ private void parseSingleRuleAndCheckToString(String rule) { } private void constructNonGroundRuleAndCheckToString(String textualRule) { - CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(parseSingleRule(textualRule))); + CompiledRule nonGroundRule = InternalRule.fromNormalRule(Rules.toNormalRule(parseSingleRule(textualRule))); assertEquals(textualRule, nonGroundRule.toString()); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java index 2fc8f87a2..3edc72515 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java @@ -47,6 +47,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.Rules; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.commons.terms.Terms; @@ -54,7 +55,6 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; -import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; import at.ac.tuwien.kr.alpha.core.test.util.SubstitutionTestUtil; import at.ac.tuwien.kr.alpha.core.util.Substitutions; @@ -114,7 +114,7 @@ public void substituteNegativeBasicAtom() { @Test public void groundAndPrintRule() { Rule rule = PARSER.parse("x :- p(X,Y), not q(X,Y).").getRules().get(0); - CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); + CompiledRule nonGroundRule = InternalRule.fromNormalRule(Rules.toNormalRule(rule)); Substitution substitution1 = BasicSubstitution.specializeSubstitution(PX, PA, BasicSubstitution.EMPTY_SUBSTITUTION); Substitution substitution2 = BasicSubstitution.specializeSubstitution(PY, PB, substitution1); String printedString = SubstitutionTestUtil.groundAndPrintRule(nonGroundRule, substitution2); @@ -169,7 +169,7 @@ private void groundLiteralToString(boolean negated) { @Test public void substitutionFromString() { Rule rule = PARSER.parse("x :- p(X,Y), not q(X,Y).").getRules().get(0); - CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); + CompiledRule nonGroundRule = InternalRule.fromNormalRule(Rules.toNormalRule(rule)); Substitution substitution1 = BasicSubstitution.specializeSubstitution(PX, PA, BasicSubstitution.EMPTY_SUBSTITUTION); Substitution substitution = BasicSubstitution.specializeSubstitution(PY, PB, substitution1); RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 4877aca6d..28e5cceef 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -61,7 +61,7 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.commons.programs.ReificationHelper; +import at.ac.tuwien.kr.alpha.commons.programs.Reifier; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; @@ -299,7 +299,7 @@ public Solver prepareSolverFor(NormalProgram program, java.util.function.Predica @Override public Set reify(ASPCore2Program program) { final IntIdGenerator intIdGen = new IntIdGenerator(0); - return new ReificationHelper(() -> { + return new Reifier(() -> { return Terms.newConstant(intIdGen.getNextId()); }).reifyProgram(program); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 88e9591cb..1606f792b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -70,6 +70,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.rules.BasicRule; import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.MethodPredicateInterpretation; @@ -79,7 +80,6 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.rules.BasicRule; public class AlphaImplTest { From f7f5e0c61a454588a9ade1a93bfc322b9d973809 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 13:20:51 +0200 Subject: [PATCH 42/96] adapt package structures: program components into program subpackages --- .../tuwien/kr/alpha/api/AnswerSetQuery.java | 2 +- .../kr/alpha/api/ComparisonOperator.java | 2 +- .../PredicateInterpretation.java | 4 +-- .../kr/alpha/api/grounder/Substitution.java | 4 +-- .../alpha/api/programs/ASPCore2Program.java | 4 +-- .../kr/alpha/api/programs/NormalProgram.java | 2 +- .../tuwien/kr/alpha/api/programs/Program.java | 4 +-- .../api/programs/atoms/AggregateAtom.java | 4 +-- .../kr/alpha/api/programs/atoms/Atom.java | 4 +-- .../api/programs/atoms/ExternalAtom.java | 2 +- .../alpha/api/programs/literals/Literal.java | 4 +-- .../api/{ => programs}/rules/NormalRule.java | 4 +-- .../alpha/api/{ => programs}/rules/Rule.java | 4 +-- .../rules/heads/ChoiceHead.java | 4 +-- .../rules/heads/DisjunctiveHead.java | 2 +- .../api/{ => programs}/rules/heads/Head.java | 2 +- .../rules/heads/NormalHead.java | 2 +- .../terms/ArithmeticOperator.java | 2 +- .../{ => programs}/terms/ArithmeticTerm.java | 2 +- .../{ => programs}/terms/ConstantTerm.java | 2 +- .../{ => programs}/terms/FunctionTerm.java | 2 +- .../{ => programs}/terms/IntervalTerm.java | 2 +- .../alpha/api/{ => programs}/terms/Term.java | 2 +- .../{ => programs}/terms/VariableTerm.java | 2 +- .../mappers/AnswerSetToWorkbookMapper.java | 2 +- .../AnswerSetToWorkbookMapperTest.java | 2 +- .../kr/alpha/commons/AnswerSetBuilder.java | 6 ++-- .../AbstractComparisonOperator.java | 2 +- .../comparisons/ComparisonOperators.java | 2 +- .../kr/alpha/commons/programs/Reifier.java | 24 +++++++-------- .../{ => programs}/atoms/AbstractAtom.java | 8 ++--- .../atoms/AggregateAtomImpl.java | 8 ++--- .../commons/{ => programs}/atoms/Atoms.java | 6 ++-- .../{ => programs}/atoms/BasicAtomImpl.java | 8 ++--- .../atoms/ComparisonAtomImpl.java | 8 ++--- .../atoms/ExternalAtomImpl.java | 8 ++--- .../literals/AbstractLiteral.java | 6 ++-- .../literals/AggregateLiteralImpl.java | 8 ++--- .../literals/BasicLiteralImpl.java | 8 ++--- .../literals/ComparisonLiteralImpl.java | 12 ++++---- .../literals/ExternalLiteralImpl.java | 10 +++---- .../{ => programs}/literals/Literals.java | 2 +- .../{ => programs}/rules/AbstractRule.java | 6 ++-- .../{ => programs}/rules/BasicRule.java | 4 +-- .../{ => programs}/rules/NormalRuleImpl.java | 6 ++-- .../commons/{ => programs}/rules/Rules.java | 12 ++++---- .../rules/heads/ChoiceHeadImpl.java | 6 ++-- .../rules/heads/DisjunctiveHeadImpl.java | 4 +-- .../{ => programs}/rules/heads/Heads.java | 12 ++++---- .../rules/heads/NormalHeadImpl.java | 4 +-- .../{ => programs}/terms/AbstractTerm.java | 10 +++---- .../terms/ArithmeticTermImpl.java | 10 +++---- .../terms/ConstantTermImpl.java | 8 ++--- .../terms/FunctionTermImpl.java | 8 ++--- .../terms/IntervalTermImpl.java | 8 ++--- .../commons/{ => programs}/terms/Terms.java | 18 +++++------ .../terms/VariableTermImpl.java | 6 ++-- .../substitutions/BasicSubstitution.java | 8 ++--- .../alpha/commons/substitutions/Instance.java | 2 +- .../alpha/commons/substitutions/Unifier.java | 4 +-- .../commons/util/AnswerSetQueryImpl.java | 6 ++-- .../kr/alpha/commons/BasicAnswerSetTest.java | 6 ++-- .../alpha/commons/programs/ReifierTest.java | 16 +++++----- .../{ => programs}/terms/TermTest.java | 14 ++++----- .../{ => programs}/terms/TermsTest.java | 4 +-- .../{ => programs}/terms/TestMinusTerm.java | 10 +++---- .../commons/util/AnswerSetQueryTest.java | 8 ++--- .../kr/alpha/core/common/Assignment.java | 4 +-- .../kr/alpha/core/common/AtomStore.java | 4 +-- .../kr/alpha/core/common/AtomStoreImpl.java | 2 +- .../tuwien/kr/alpha/core/common/NoGood.java | 10 +++---- .../BinaryPredicateInterpretation.java | 2 +- .../BindingMethodPredicateInterpretation.java | 4 +-- .../IntPredicateInterpretation.java | 2 +- .../LongPredicateInterpretation.java | 2 +- .../MethodPredicateInterpretation.java | 2 +- .../NonBindingPredicateInterpretation.java | 4 +-- .../SuppliedPredicateInterpretation.java | 4 +-- .../UnaryPredicateInterpretation.java | 2 +- .../core/depgraph/DependencyGraphImpl.java | 2 +- .../core/externals/AspStandardLibrary.java | 4 +-- .../kr/alpha/core/externals/Externals.java | 6 ++-- .../alpha/core/grounder/BridgedGrounder.java | 2 +- .../alpha/core/grounder/ChoiceRecorder.java | 8 ++--- .../core/grounder/FactIntervalEvaluator.java | 10 +++---- .../kr/alpha/core/grounder/Grounder.java | 2 +- .../core/grounder/IndexedInstanceStorage.java | 2 +- .../kr/alpha/core/grounder/NaiveGrounder.java | 12 ++++---- .../alpha/core/grounder/NoGoodGenerator.java | 12 ++++---- .../grounder/ProgramAnalyzingGrounder.java | 2 +- .../core/grounder/RuleGroundingInfoImpl.java | 4 +-- .../core/grounder/RuleGroundingOrderImpl.java | 2 +- .../kr/alpha/core/grounder/Unification.java | 8 ++--- .../alpha/core/grounder/bridges/Bridge.java | 2 +- .../AbstractLiteralInstantiationStrategy.java | 2 +- .../LiteralInstantiationResult.java | 2 +- .../instantiation/LiteralInstantiator.java | 4 +-- .../structure/AnalyzeUnjustified.java | 8 ++--- .../alpha/core/parser/ParseTreeVisitor.java | 30 +++++++++---------- .../alpha/core/parser/ProgramPartParser.java | 2 +- .../alpha/core/programs/AbstractProgram.java | 4 +-- .../alpha/core/programs/AnalyzedProgram.java | 2 +- .../alpha/core/programs/CompiledProgram.java | 2 +- .../kr/alpha/core/programs/InputProgram.java | 4 +-- .../alpha/core/programs/InternalProgram.java | 12 ++++---- .../core/programs/NormalProgramImpl.java | 8 ++--- .../core/{ => programs}/atoms/ChoiceAtom.java | 10 +++---- .../{ => programs}/atoms/EnumerationAtom.java | 10 +++---- .../atoms/EnumerationLiteral.java | 8 ++--- .../{ => programs}/atoms/IntervalAtom.java | 10 +++---- .../{ => programs}/atoms/IntervalLiteral.java | 14 ++++----- .../core/{ => programs}/atoms/Literals.java | 2 +- .../core/{ => programs}/atoms/RuleAtom.java | 12 ++++---- .../{ => programs}/rules/CompiledRule.java | 4 +-- .../{ => programs}/rules/InternalRule.java | 14 ++++----- .../ArithmeticTermsRewriting.java | 24 +++++++-------- .../transformation/ChoiceHeadToNormal.java | 18 +++++------ .../transformation/EnumerationRewriting.java | 14 ++++----- .../IntervalTermToIntervalAtom.java | 20 ++++++------- .../NormalizeProgramTransformation.java | 2 +- .../transformation/PredicateInternalizer.java | 12 ++++---- .../transformation/ProgramTransformation.java | 2 +- .../transformation/StratifiedEvaluation.java | 4 +-- .../VariableEqualityRemoval.java | 16 +++++----- .../aggregates/AggregateLiteralSplitting.java | 8 ++--- .../AggregateOperatorNormalization.java | 18 +++++------ .../aggregates/AggregateRewriting.java | 8 ++--- .../aggregates/AggregateRewritingContext.java | 12 ++++---- .../AggregateRewritingRuleAnalysis.java | 10 +++---- .../encoders/AbstractAggregateEncoder.java | 16 +++++----- .../aggregates/encoders/MinMaxEncoder.java | 20 ++++++------- .../StringtemplateBasedAggregateEncoder.java | 12 ++++---- .../aggregates/encoders/SumEncoder.java | 8 ++--- .../tuwien/kr/alpha/core/solver/Choice.java | 4 +-- .../kr/alpha/core/solver/ChoiceManager.java | 2 +- .../kr/alpha/core/solver/DefaultSolver.java | 12 ++++---- .../core/solver/LearnedNoGoodDeletion.java | 2 +- .../alpha/core/solver/NaiveNoGoodStore.java | 2 +- .../kr/alpha/core/solver/NaiveSolver.java | 6 ++-- .../core/solver/NoGoodStoreAlphaRoaming.java | 10 +++---- .../kr/alpha/core/solver/TrailAssignment.java | 6 ++-- .../kr/alpha/core/solver/WatchedNoGood.java | 2 +- .../alpha/core/solver/WritableAssignment.java | 4 +-- .../heuristics/AlphaActiveRuleHeuristic.java | 2 +- .../alpha/core/solver/heuristics/BerkMin.java | 6 ++-- .../solver/heuristics/BerkMinLiteral.java | 2 +- .../solver/heuristics/BranchingHeuristic.java | 2 +- .../heuristics/DependencyDrivenHeuristic.java | 4 +-- .../GeneralizedDependencyDrivenHeuristic.java | 2 +- .../solver/heuristics/HeapOfActiveAtoms.java | 2 +- .../heuristics/HeapOfActiveChoicePoints.java | 2 +- .../solver/heuristics/NaiveHeuristic.java | 2 +- .../solver/heuristics/ReplayHeuristic.java | 2 +- .../alpha/core/solver/heuristics/VSIDS.java | 6 ++-- .../activity/BodyActivityProvider.java | 2 +- .../learning/GroundConflictNoGoodLearner.java | 2 +- .../kr/alpha/core/util/Substitutions.java | 6 ++-- .../kr/alpha/core/common/NoGoodTest.java | 2 +- .../tuwien/kr/alpha/core/common/RuleTest.java | 10 +++---- .../externals/AspStandardLibraryTest.java | 4 +-- .../alpha/core/grounder/ChoiceGrounder.java | 16 +++++----- .../kr/alpha/core/grounder/DummyGrounder.java | 14 ++++----- .../grounder/IndexedInstanceStorageTest.java | 4 +-- .../core/grounder/NaiveGrounderTest.java | 8 ++--- .../core/grounder/NoGoodGeneratorTest.java | 12 ++++---- .../core/grounder/RuleGroundingOrderTest.java | 2 +- .../alpha/core/grounder/RuleToStringTest.java | 10 +++---- .../alpha/core/grounder/SubstitutionTest.java | 26 ++++++++-------- .../alpha/core/grounder/UnificationTest.java | 2 +- .../kr/alpha/core/grounder/UnifierTest.java | 6 ++-- .../LiteralInstantiationStrategyTest.java | 6 ++-- .../LiteralInstantiatorTest.java | 12 ++++---- .../structure/AnalyzeUnjustifiedTest.java | 4 +-- .../kr/alpha/core/parser/ParserTest.java | 14 ++++----- .../core/{ => programs}/atoms/AtomsTest.java | 6 ++-- ...LiteralBindingNonBindingVariablesTest.java | 8 ++--- .../ArithmeticTermsRewritingTest.java | 8 ++--- .../StratifiedEvaluationRegressionTest.java | 4 +-- .../StratifiedEvaluationTest.java | 4 +-- .../AggregateLiteralSplittingTest.java | 4 +-- .../AggregateOperatorNormalizationTest.java | 12 ++++---- .../AggregateRewritingContextTest.java | 8 ++--- .../AggregateRewritingRuleAnalysisTest.java | 12 ++++---- .../aggregates/AggregateRewritingTest.java | 4 +-- .../alpha/core/solver/AtomCounterTests.java | 18 +++++------ .../alpha/core/solver/ChoiceManagerTests.java | 4 +-- .../kr/alpha/core/solver/HanoiTowerTest.java | 6 ++-- .../kr/alpha/core/solver/SolverTests.java | 6 ++-- .../solver/ThreeColouringRandomGraphTest.java | 6 ++-- .../solver/ThreeColouringTestWithRandom.java | 6 ++-- .../core/solver/ThreeColouringWheelTest.java | 6 ++-- .../AlphaHeuristicTestAssumptions.java | 2 +- .../heuristics/HeapOfActiveAtomsTest.java | 2 +- .../solver/heuristics/HeuristicTestUtils.java | 2 +- .../heuristics/ReplayHeuristicTest.java | 2 +- .../core/solver/heuristics/VSIDSTest.java | 2 +- .../kr/alpha/core/test/util/RuleParser.java | 4 +-- .../core/test/util/SubstitutionTestUtil.java | 2 +- .../kr/alpha/core/test/util/TestUtils.java | 6 ++-- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 2 +- .../kr/alpha/api/impl/AlphaImplTest.java | 16 +++++----- .../impl/FixedInterpretationLiteralsTest.java | 6 ++-- 202 files changed, 660 insertions(+), 658 deletions(-) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/NormalRule.java (73%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/Rule.java (81%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/heads/ChoiceHead.java (85%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/heads/DisjunctiveHead.java (81%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/heads/Head.java (65%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/rules/heads/NormalHead.java (84%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/ArithmeticOperator.java (94%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/ArithmeticTerm.java (84%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/ConstantTerm.java (84%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/FunctionTerm.java (81%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/IntervalTerm.java (84%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/Term.java (94%) rename alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/{ => programs}/terms/VariableTerm.java (75%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/AbstractAtom.java (93%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/AggregateAtomImpl.java (97%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/Atoms.java (93%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/BasicAtomImpl.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/ComparisonAtomImpl.java (94%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/ExternalAtomImpl.java (96%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/AbstractLiteral.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/AggregateLiteralImpl.java (90%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/BasicLiteralImpl.java (93%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/ComparisonLiteralImpl.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/ExternalLiteralImpl.java (96%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/literals/Literals.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/AbstractRule.java (96%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/BasicRule.java (94%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/NormalRuleImpl.java (73%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/Rules.java (80%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/heads/ChoiceHeadImpl.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/heads/DisjunctiveHeadImpl.java (91%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/heads/Heads.java (66%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/rules/heads/NormalHeadImpl.java (90%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/AbstractTerm.java (91%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/ArithmeticTermImpl.java (95%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/ConstantTermImpl.java (94%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/FunctionTermImpl.java (94%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/IntervalTermImpl.java (92%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/Terms.java (89%) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/VariableTermImpl.java (94%) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/TermTest.java (93%) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/TermsTest.java (88%) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/terms/TestMinusTerm.java (86%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/ChoiceAtom.java (93%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/EnumerationAtom.java (95%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/EnumerationLiteral.java (85%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/IntervalAtom.java (93%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/IntervalLiteral.java (92%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/Literals.java (98%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/RuleAtom.java (91%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/rules/CompiledRule.java (76%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/{ => programs}/rules/InternalRule.java (93%) rename alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/AtomsTest.java (96%) rename alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/{ => programs}/atoms/LiteralBindingNonBindingVariablesTest.java (97%) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java index dcd015a21..14aab16a3 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java @@ -3,7 +3,7 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * A {@link java.util.function.Predicate} testing {@link Atom}s in order to query {@link AnswerSet}s for {@link Atom}s satisfying a specific diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/ComparisonOperator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/ComparisonOperator.java index b6cbfb168..ca649725d 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/ComparisonOperator.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/ComparisonOperator.java @@ -2,7 +2,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * A comparison operator that can be used in {@link ASPCore2Program}s. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/common/fixedinterpretations/PredicateInterpretation.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/common/fixedinterpretations/PredicateInterpretation.java index 655fff135..bbe8680bf 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/common/fixedinterpretations/PredicateInterpretation.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/common/fixedinterpretations/PredicateInterpretation.java @@ -30,8 +30,8 @@ import java.util.List; import java.util.Set; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import static java.util.Collections.*; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/grounder/Substitution.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/grounder/Substitution.java index 3bc416b54..7a9d5a3c3 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/grounder/Substitution.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/grounder/Substitution.java @@ -2,8 +2,8 @@ import java.util.TreeMap; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * A mapping from {@link VariableTerm}s to {@link Term}s used during grounding to represent ground instances of terms, literals and rules. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java index 00d11f974..24a64615e 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.api.programs; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; /** * A {@link Program} that conforms to Alphas implementation of the ASP-Core2-Standard. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/NormalProgram.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/NormalProgram.java index 92734afab..c6eff6bea 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/NormalProgram.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/NormalProgram.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; /** * A {@link Program} consisting only of facts and {@link NormalRule}s, i.e. no disjunctive- or choice-rules, and no aggregates in rule bodies. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/Program.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/Program.java index 2e8c0f528..eeb251945 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/Program.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/Program.java @@ -3,8 +3,8 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; /** * An ASP program as accepted by Alpha. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AggregateAtom.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AggregateAtom.java index 4dae7148c..bd5127cf2 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AggregateAtom.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AggregateAtom.java @@ -5,8 +5,8 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * An {@link Atom} representing a comparison over an aggregate function, for example '13 < #sum{ X : p(X) }'. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/Atom.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/Atom.java index c5cffbbfd..8d014fd04 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/Atom.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/Atom.java @@ -6,8 +6,8 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * An Atom is the common super-interface of all representations of ASP atoms used by Alpha. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/ExternalAtom.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/ExternalAtom.java index 42b4f110e..d4b2f946c 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/ExternalAtom.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/ExternalAtom.java @@ -4,7 +4,7 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.VariableNormalizableAtom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * An external atom, i.e. an {@link Atom} that is interpreted by calling a linked Java-Method. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java index 020376893..4824480e9 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/literals/Literal.java @@ -6,8 +6,8 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * A literal according to the ASP Core 2 Standard. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java similarity index 73% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java index 60aabfc42..8f2d8ebc8 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/NormalRule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java @@ -1,7 +1,7 @@ -package at.ac.tuwien.kr.alpha.api.rules; +package at.ac.tuwien.kr.alpha.api.programs.rules; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; /** * A {@link Rule} with a {@link NormalHead}. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/Rule.java similarity index 81% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/Rule.java index f3b5a028b..b9a319bbc 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/Rule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/Rule.java @@ -1,9 +1,9 @@ -package at.ac.tuwien.kr.alpha.api.rules; +package at.ac.tuwien.kr.alpha.api.programs.rules; import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; /** * A rule as defined in the ASP Core 2 Standard. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ChoiceHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ChoiceHead.java similarity index 85% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ChoiceHead.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ChoiceHead.java index 2adf05d2c..c9d7011af 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/ChoiceHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ChoiceHead.java @@ -1,11 +1,11 @@ -package at.ac.tuwien.kr.alpha.api.rules.heads; +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; import java.util.List; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * A choice head as defined by the ASP Core 2 Standard. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/DisjunctiveHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/DisjunctiveHead.java similarity index 81% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/DisjunctiveHead.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/DisjunctiveHead.java index 24d19172f..f2237833e 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/DisjunctiveHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/DisjunctiveHead.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.rules.heads; +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; /** * Deprecated - A disjunctive head (see ASP Core 2 Standard). Should be removed since disjunction is not actually supported by Alpha. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/Head.java similarity index 65% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/Head.java index 909db79fc..20cef5933 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/Head.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/Head.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.rules.heads; +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; /** * The head of an ASP rule. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/NormalHead.java similarity index 84% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/NormalHead.java index 64c335807..c9a1ee01c 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/rules/heads/NormalHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/NormalHead.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.rules.heads; +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticOperator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticOperator.java similarity index 94% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticOperator.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticOperator.java index 33be0a5e9..9203e9d33 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticOperator.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticOperator.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; import com.google.common.math.IntMath; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticTerm.java similarity index 84% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticTerm.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticTerm.java index 8f0551d89..ce58b8028 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ArithmeticTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ArithmeticTerm.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; /** * A {@link Term} that is a binary arithmetic expression. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ConstantTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ConstantTerm.java similarity index 84% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ConstantTerm.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ConstantTerm.java index bc41438d0..0c43dfb5d 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/ConstantTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ConstantTerm.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; /** * A term consisting of a constant symbol. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/FunctionTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/FunctionTerm.java similarity index 81% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/FunctionTerm.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/FunctionTerm.java index a524ca619..88cb6a2c5 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/FunctionTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/FunctionTerm.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; import java.util.List; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/IntervalTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/IntervalTerm.java similarity index 84% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/IntervalTerm.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/IntervalTerm.java index 3e3a7f394..ddb071f06 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/IntervalTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/IntervalTerm.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; /** * A term representing an interval of integers. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/Term.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/Term.java similarity index 94% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/Term.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/Term.java index 4ed768155..840f6ee3b 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/Term.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/Term.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; import java.util.Map; import java.util.Set; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/VariableTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/VariableTerm.java similarity index 75% rename from alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/VariableTerm.java rename to alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/VariableTerm.java index d735ed942..eee71fcfb 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/VariableTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/VariableTerm.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.terms; +package at.ac.tuwien.kr.alpha.api.programs.terms; /** * A term representing a variable symbol in ASP programs. diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapper.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapper.java index 4fc5e81ee..8b7278921 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapper.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapper.java @@ -43,7 +43,7 @@ import at.ac.tuwien.kr.alpha.api.mapper.AnswerSetToObjectMapper; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * Implementation of {@link AnswerSetToObjectMapper} that generates an office open xml workbook ("excel file") from a given answer set. diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java index a2433d692..2e9e9fba0 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java @@ -19,7 +19,7 @@ import at.ac.tuwien.kr.alpha.api.impl.AlphaImpl; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; public class AnswerSetToWorkbookMapperTest { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSetBuilder.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSetBuilder.java index ca8d6db68..68dabf24a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSetBuilder.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSetBuilder.java @@ -13,9 +13,9 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public class AnswerSetBuilder { private boolean firstInstance = true; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/AbstractComparisonOperator.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/AbstractComparisonOperator.java index 2ea96c01f..b13098d12 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/AbstractComparisonOperator.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/AbstractComparisonOperator.java @@ -4,7 +4,7 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; abstract class AbstractComparisonOperator implements ComparisonOperator { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/ComparisonOperators.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/ComparisonOperators.java index 1b851da26..bb66df705 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/ComparisonOperators.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/comparisons/ComparisonOperators.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.commons.comparisons; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; public class ComparisonOperators { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index 2d1e729c6..cbe76be98 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -18,20 +18,20 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public class Reifier { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AbstractAtom.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AbstractAtom.java similarity index 93% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AbstractAtom.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AbstractAtom.java index f55611a0f..4a54b90f4 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AbstractAtom.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AbstractAtom.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.List; import java.util.Set; @@ -34,9 +34,9 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** * An Atom is the common superclass of all representations of ASP atoms used by Alpha. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AggregateAtomImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AggregateAtomImpl.java similarity index 97% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AggregateAtomImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AggregateAtomImpl.java index 964728e57..206bf9782 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/AggregateAtomImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AggregateAtomImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import static at.ac.tuwien.kr.alpha.commons.util.Util.join; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; @@ -40,9 +40,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; class AggregateAtomImpl extends AbstractAtom implements AggregateAtom { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/Atoms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java similarity index 93% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/Atoms.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java index ed7b95ddc..8c3254e61 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/Atoms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.Arrays; import java.util.Collections; @@ -14,8 +14,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.atoms.AggregateAtomImpl.AggregateElementImpl; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AggregateAtomImpl.AggregateElementImpl; public final class Atoms { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImpl.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImpl.java index 6b7cc57e5..ebe1c8266 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.Arrays; import java.util.Collections; @@ -37,9 +37,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ComparisonAtomImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ComparisonAtomImpl.java similarity index 94% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ComparisonAtomImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ComparisonAtomImpl.java index 52d063427..1d4a9fd3a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ComparisonAtomImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ComparisonAtomImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.Arrays; import java.util.List; @@ -37,9 +37,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** * Represents a builtin comparison atom according to the standard. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImpl.java similarity index 96% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImpl.java index e5e5ef5e6..79cddde75 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.atoms; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.Collections; import java.util.List; @@ -38,9 +38,9 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ExternalLiteral; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; class ExternalAtomImpl extends AbstractAtom implements ExternalAtom { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AbstractLiteral.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AbstractLiteral.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AbstractLiteral.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AbstractLiteral.java index 8d96711b1..76686365a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AbstractLiteral.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AbstractLiteral.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import java.util.List; import java.util.Set; @@ -36,8 +36,8 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * A potentially negated {@link AbstractAtom} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AggregateLiteralImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AggregateLiteralImpl.java similarity index 90% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AggregateLiteralImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AggregateLiteralImpl.java index 082d5cf5d..b5cdfb799 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/AggregateLiteralImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/AggregateLiteralImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import java.util.HashSet; import java.util.Set; @@ -7,10 +7,10 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; /** * Copyright (c) 2018, the Alpha Team. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/BasicLiteralImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/BasicLiteralImpl.java similarity index 93% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/BasicLiteralImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/BasicLiteralImpl.java index 4f0479d1f..3635d0b51 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/BasicLiteralImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/BasicLiteralImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import java.util.Collections; import java.util.HashSet; @@ -35,9 +35,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; /** * Contains a potentially negated {@link BasicAtomImpl}. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ComparisonLiteralImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ComparisonLiteralImpl.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ComparisonLiteralImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ComparisonLiteralImpl.java index cad9d1121..820de3e3f 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ComparisonLiteralImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ComparisonLiteralImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import java.util.Collections; import java.util.HashSet; @@ -38,13 +38,13 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; /** * Contains a potentially negated {@link ComparisonAtomImpl}. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ExternalLiteralImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ExternalLiteralImpl.java similarity index 96% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ExternalLiteralImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ExternalLiteralImpl.java index bcd1b7e0a..c2d87b3e6 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/ExternalLiteralImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/ExternalLiteralImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import java.util.ArrayList; import java.util.Collections; @@ -37,10 +37,10 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ExternalLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/Literals.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/Literals.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/Literals.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/Literals.java index a7ec8a770..82b91f24b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/literals/Literals.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/literals/Literals.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.literals; +package at.ac.tuwien.kr.alpha.commons.programs.literals; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java similarity index 96% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java index 44f5800b1..9326cad6b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.rules; +package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.Collections; import java.util.LinkedHashSet; @@ -9,8 +9,8 @@ import org.apache.commons.collections4.SetUtils; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java similarity index 94% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java index df1e8cd25..e2bd1e178 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java @@ -25,12 +25,12 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.rules; +package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; /** * Represents a non-ground rule or a constraint. A {@link BasicRule} has a general {@link Head}, meaning both choice heads and disjunctive diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java similarity index 73% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java index 4c0f5585a..828560f6f 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java @@ -1,10 +1,10 @@ -package at.ac.tuwien.kr.alpha.commons.rules; +package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; /** * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java similarity index 80% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index 0eda75344..dc0396863 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,15 +1,15 @@ -package at.ac.tuwien.kr.alpha.commons.rules; +package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.ArrayList; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.util.Util; public final class Rules { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ChoiceHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ChoiceHeadImpl.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ChoiceHeadImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ChoiceHeadImpl.java index 7c81d7357..5af548b01 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ChoiceHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ChoiceHeadImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.rules.heads; +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; import static at.ac.tuwien.kr.alpha.commons.util.Util.join; @@ -7,8 +7,8 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * Represents the head of a choice rule. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/DisjunctiveHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/DisjunctiveHeadImpl.java similarity index 91% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/DisjunctiveHeadImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/DisjunctiveHeadImpl.java index bc33e8f17..d463d8b4f 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/DisjunctiveHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/DisjunctiveHeadImpl.java @@ -1,11 +1,11 @@ -package at.ac.tuwien.kr.alpha.commons.rules.heads; +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; import static at.ac.tuwien.kr.alpha.commons.util.Util.join; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.heads.DisjunctiveHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.DisjunctiveHead; /** * Copyright (c) 2017, the Alpha Team. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java similarity index 66% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java index 9e529a7e7..6e7aeebf1 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java @@ -1,15 +1,15 @@ -package at.ac.tuwien.kr.alpha.commons.rules.heads; +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; import java.util.List; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; public final class Heads { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java similarity index 90% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java index 2cdfc4404..7bae74aba 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/NormalHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java @@ -1,7 +1,7 @@ -package at.ac.tuwien.kr.alpha.commons.rules.heads; +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; /** * Represents a normal head, i.e., a head that is an Atom. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractTerm.java similarity index 91% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractTerm.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractTerm.java index 5db258d85..f9d1c3d7d 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/AbstractTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractTerm.java @@ -1,14 +1,14 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.HashMap; import java.util.Map; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; //@formatter:off /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ArithmeticTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ArithmeticTermImpl.java similarity index 95% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ArithmeticTermImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ArithmeticTermImpl.java index fd2b780aa..8df7a76e8 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ArithmeticTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ArithmeticTermImpl.java @@ -25,16 +25,16 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.LinkedHashSet; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Interner; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ConstantTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ConstantTermImpl.java similarity index 94% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ConstantTermImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ConstantTermImpl.java index 4dcaec598..11e163d54 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/ConstantTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ConstantTermImpl.java @@ -1,12 +1,12 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.Collections; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Interner; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/FunctionTermImpl.java similarity index 94% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/FunctionTermImpl.java index 14b8535de..dd7a2e396 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/FunctionTermImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.ArrayList; import java.util.Arrays; @@ -8,9 +8,9 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Interner; import at.ac.tuwien.kr.alpha.commons.util.Util; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/IntervalTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/IntervalTermImpl.java similarity index 92% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/IntervalTermImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/IntervalTermImpl.java index eb14b44f7..f91af0c40 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/IntervalTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/IntervalTermImpl.java @@ -1,12 +1,12 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.LinkedHashSet; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Interner; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java similarity index 89% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java index c651a70aa..d38088b6b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java @@ -1,19 +1,19 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.ArrayList; import java.util.List; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.ArithmeticTermImpl.MinusTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; -import at.ac.tuwien.kr.alpha.commons.terms.ArithmeticTermImpl.MinusTerm; /** * Convenience methods for {@link Term}s. The methods provided here are an diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/VariableTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/VariableTermImpl.java similarity index 94% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/VariableTermImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/VariableTermImpl.java index 5e892b480..221c83aa4 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/VariableTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/VariableTermImpl.java @@ -1,11 +1,11 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import java.util.Collections; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Interner; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java index df8d26d6a..d7bd34bf0 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java @@ -36,10 +36,10 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Util; public class BasicSubstitution implements at.ac.tuwien.kr.alpha.api.grounder.Substitution { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Instance.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Instance.java index aa707ff36..dca9d526c 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Instance.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Instance.java @@ -6,7 +6,7 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Unifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Unifier.java index 06033cf51..90889b3ce 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Unifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/Unifier.java @@ -10,8 +10,8 @@ import java.util.TreeMap; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * A variable substitution allowing variables to occur on the right-hand side. Chains of variable substitutions are diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java index ccb89f6c5..146edfd0a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java @@ -10,9 +10,9 @@ import at.ac.tuwien.kr.alpha.api.AnswerSetQuery; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; /** * A query for ASP atoms matching a set of filter predicates. diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSetTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSetTest.java index 5c1de5dcf..fff2ef4e3 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSetTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSetTest.java @@ -16,9 +16,9 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** * Copyright (c) 2016, the Alpha Team. diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java index 35af2717c..fdc215a05 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java @@ -20,16 +20,16 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; public class ReifierTest { diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermTest.java similarity index 93% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermTest.java index ebb36c0b8..32c44da2d 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermTest.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; @@ -13,12 +13,12 @@ import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; /** diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java similarity index 88% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java index 4c4600dc8..b8612344a 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -6,7 +6,7 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; public class TermsTest { diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TestMinusTerm.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TestMinusTerm.java similarity index 86% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TestMinusTerm.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TestMinusTerm.java index ea7a02728..71132647c 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TestMinusTerm.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TestMinusTerm.java @@ -23,16 +23,16 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.commons.terms; +package at.ac.tuwien.kr.alpha.commons.programs.terms; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.Term.RenameCounter; -import at.ac.tuwien.kr.alpha.commons.terms.AbstractTerm.RenameCounterImpl; -import at.ac.tuwien.kr.alpha.commons.terms.ArithmeticTermImpl.MinusTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term.RenameCounter; +import at.ac.tuwien.kr.alpha.commons.programs.terms.AbstractTerm.RenameCounterImpl; +import at.ac.tuwien.kr.alpha.commons.programs.terms.ArithmeticTermImpl.MinusTerm; /** * Tests {@link MinusTerm} diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java index cc81e6af9..a2775aa24 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java @@ -14,13 +14,13 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public class AnswerSetQueryTest { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/Assignment.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/Assignment.java index 47ae1790a..961323c41 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/Assignment.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/Assignment.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.core.common; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isNegated; import java.util.Set; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStore.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStore.java index e55c6fcfb..c02edbd48 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStore.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStore.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.core.common; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isNegated; import java.util.Iterator; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStoreImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStoreImpl.java index 4f9cf9a55..646a172a1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStoreImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/AtomStoreImpl.java @@ -37,7 +37,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.solver.AtomCounter; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java index 3575669ba..b0277baba 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java @@ -27,15 +27,15 @@ */ package at.ac.tuwien.kr.alpha.core.common; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.negateLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.positiveLiteral; import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.INTERNAL; import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.LEARNT; import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.STATIC; import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.SUPPORT; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isNegated; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.negateLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.positiveLiteral; import java.util.Arrays; import java.util.Iterator; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BinaryPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BinaryPredicateInterpretation.java index d0f62b756..e71e56aa1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BinaryPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BinaryPredicateInterpretation.java @@ -29,7 +29,7 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; public class BinaryPredicateInterpretation extends NonBindingPredicateInterpretation { private final java.util.function.BiPredicate predicate; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BindingMethodPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BindingMethodPredicateInterpretation.java index a73aae4b2..04eda3c1a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BindingMethodPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/BindingMethodPredicateInterpretation.java @@ -36,8 +36,8 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.BindingPredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; public class BindingMethodPredicateInterpretation implements BindingPredicateInterpretation { private final Method method; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/IntPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/IntPredicateInterpretation.java index dd8acc05e..f77e18429 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/IntPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/IntPredicateInterpretation.java @@ -29,7 +29,7 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; public class IntPredicateInterpretation extends NonBindingPredicateInterpretation { private final java.util.function.IntPredicate predicate; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/LongPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/LongPredicateInterpretation.java index e5ef94663..9c5a08f2b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/LongPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/LongPredicateInterpretation.java @@ -29,7 +29,7 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; public class LongPredicateInterpretation extends NonBindingPredicateInterpretation { private final java.util.function.LongPredicate predicate; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/MethodPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/MethodPredicateInterpretation.java index ff7dc78f6..e4afa4c39 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/MethodPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/MethodPredicateInterpretation.java @@ -29,7 +29,7 @@ import org.apache.commons.lang3.ClassUtils; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/NonBindingPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/NonBindingPredicateInterpretation.java index 53ad2350b..26c84ed23 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/NonBindingPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/NonBindingPredicateInterpretation.java @@ -28,8 +28,8 @@ package at.ac.tuwien.kr.alpha.core.common.fixedinterpretations; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import java.util.ArrayList; import java.util.List; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/SuppliedPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/SuppliedPredicateInterpretation.java index a29adffbf..4e5f72637 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/SuppliedPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/SuppliedPredicateInterpretation.java @@ -28,8 +28,8 @@ package at.ac.tuwien.kr.alpha.core.common.fixedinterpretations; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.BindingPredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import java.util.List; import java.util.Set; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/UnaryPredicateInterpretation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/UnaryPredicateInterpretation.java index 5e90b4712..fbc170287 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/UnaryPredicateInterpretation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/fixedinterpretations/UnaryPredicateInterpretation.java @@ -29,7 +29,7 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; public class UnaryPredicateInterpretation extends NonBindingPredicateInterpretation { private final java.util.function.Predicate predicate; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/depgraph/DependencyGraphImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/depgraph/DependencyGraphImpl.java index e2e2200af..a58120ac6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/depgraph/DependencyGraphImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/depgraph/DependencyGraphImpl.java @@ -41,7 +41,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.FixedInterpretationLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Internal representation of an {@link at.ac.tuwien.kr.alpha.core.programs.InternalProgram}'s dependency graph. The dependency graph tracks dependencies diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibrary.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibrary.java index 30aad5eed..359692f79 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibrary.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibrary.java @@ -32,8 +32,8 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.externals.Predicate; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** * Collection of methods that can be used as external atoms from ASP programs. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/Externals.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/Externals.java index a4e02806a..aa9153e95 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/Externals.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/externals/Externals.java @@ -40,10 +40,10 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.BinaryPredicateInterpretation; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.BindingMethodPredicateInterpretation; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.IntPredicateInterpretation; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java index 406ced3b0..8ebf24cb7 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/BridgedGrounder.java @@ -8,7 +8,7 @@ import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.grounder.bridges.Bridge; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; public abstract class BridgedGrounder extends AbstractGrounder { protected final Bridge[] bridges; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceRecorder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceRecorder.java index 19b012b41..375bf6410 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceRecorder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceRecorder.java @@ -28,18 +28,18 @@ package at.ac.tuwien.kr.alpha.core.grounder; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; import java.util.*; -import static at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom.off; -import static at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom.on; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.*; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom.off; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom.on; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.*; import static java.util.Collections.emptyList; public class ChoiceRecorder { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/FactIntervalEvaluator.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/FactIntervalEvaluator.java index 508f25cbe..e68bbc67b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/FactIntervalEvaluator.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/FactIntervalEvaluator.java @@ -5,12 +5,12 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; /** * Helper functions to evaluate facts potentially containing intervals. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Grounder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Grounder.java index 2c697f955..d6cdecbb9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Grounder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Grounder.java @@ -33,10 +33,10 @@ import org.apache.commons.lang3.tuple.Pair; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; public interface Grounder { /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java index 2be5302a5..1c051b8d1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java @@ -38,7 +38,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounder.java index 1e498d50d..2675337ce 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounder.java @@ -28,7 +28,7 @@ package at.ac.tuwien.kr.alpha.core.grounder; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.ArrayList; import java.util.Collection; @@ -54,14 +54,12 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSets; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; @@ -75,7 +73,9 @@ import at.ac.tuwien.kr.alpha.core.grounder.instantiation.LiteralInstantiator; import at.ac.tuwien.kr.alpha.core.grounder.structure.AnalyzeUnjustified; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * A semi-naive grounder. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGenerator.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGenerator.java index 3d97e7fa6..1b06cdec3 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGenerator.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGenerator.java @@ -27,9 +27,9 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.negateLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.negateLiteral; import static java.util.Collections.emptyList; import static java.util.Collections.singletonList; @@ -46,12 +46,12 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.FixedInterpretationLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.NoGood; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Class to generate ground NoGoods out of non-ground rules and grounding substitutions. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ProgramAnalyzingGrounder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ProgramAnalyzingGrounder.java index d64388123..3a993736e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ProgramAnalyzingGrounder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/ProgramAnalyzingGrounder.java @@ -5,7 +5,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.core.common.Assignment; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Copyright (c) 2017, the Alpha Team. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoImpl.java index 7ec5430f3..9ea901c8e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingInfoImpl.java @@ -39,8 +39,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Provides the grounder with information on the order to ground the literals in the body of a rule. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java index bd7c8ffa1..0f72c8f3c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderImpl.java @@ -29,7 +29,7 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * A grounding order computed by {@link RuleGroundingInfoImpl} for a specific {@link InternalRule} and a specific starting literal. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Unification.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Unification.java index ab2647942..4da06621f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Unification.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/Unification.java @@ -32,10 +32,10 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java index 2d0beedb2..b835551a1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/bridges/Bridge.java @@ -3,7 +3,7 @@ import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import java.util.Collection; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/AbstractLiteralInstantiationStrategy.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/AbstractLiteralInstantiationStrategy.java index 9547b94dd..88e4c772d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/AbstractLiteralInstantiationStrategy.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/AbstractLiteralInstantiationStrategy.java @@ -33,7 +33,7 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java index 6d2506543..b8773af6a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationResult.java @@ -35,7 +35,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Representation of the result of instantiating, i.e. finding ground instances for a literal, as performed by diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiator.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiator.java index e6fead4c6..68d3839fc 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiator.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiator.java @@ -37,8 +37,8 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.FixedInterpretationLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationLiteral; -import at.ac.tuwien.kr.alpha.core.atoms.IntervalLiteral; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationLiteral; +import at.ac.tuwien.kr.alpha.core.programs.atoms.IntervalLiteral; /** * Provides ground instantiations for literals. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustified.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustified.java index cb12167db..751f68599 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustified.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustified.java @@ -21,17 +21,17 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.grounder.Unification; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.solver.ThriceTruth; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 4eecbefe8..5a396e423 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -52,24 +52,24 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java index bc2690666..f34a8eee8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java @@ -38,7 +38,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java index 31a3617af..619e76948 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java @@ -5,8 +5,8 @@ import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AnalyzedProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AnalyzedProgram.java index c6e68c7ee..e3dd5336e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AnalyzedProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AnalyzedProgram.java @@ -11,7 +11,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.core.depgraph.ComponentGraphImpl; import at.ac.tuwien.kr.alpha.core.depgraph.StronglyConnectedComponentsAlgorithm; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/CompiledProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/CompiledProgram.java index ab307bb67..83cb2e255 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/CompiledProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/CompiledProgram.java @@ -6,7 +6,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; public interface CompiledProgram extends Program { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java index e9ba20032..9711a1e89 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java @@ -34,8 +34,8 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index e166b081f..ff98ee41b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -12,14 +12,14 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.grounder.FactIntervalEvaluator; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * A program in the internal representation needed for grounder and solver, i.e.: rules must have normal heads, all diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java index 458d6e41d..c708509b9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java @@ -7,10 +7,10 @@ import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; /** * A program that only contains NormalRules. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/ChoiceAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/ChoiceAtom.java similarity index 93% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/ChoiceAtom.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/ChoiceAtom.java index 5c6af0bde..3fc3c74c0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/ChoiceAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/ChoiceAtom.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.Collections; import java.util.List; @@ -35,11 +35,11 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; public class ChoiceAtom implements Atom { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationAtom.java similarity index 95% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationAtom.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationAtom.java index d66f1989a..97b9865fc 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationAtom.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.ArrayList; import java.util.HashMap; @@ -9,12 +9,12 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationLiteral.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationLiteral.java similarity index 85% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationLiteral.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationLiteral.java index f45e5032d..d66d45055 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/EnumerationLiteral.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/EnumerationLiteral.java @@ -1,13 +1,13 @@ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.Collections; import java.util.HashSet; import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.literals.AbstractLiteral; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.literals.AbstractLiteral; /** * Copyright (c) 2018, the Alpha Team. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalAtom.java similarity index 93% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalAtom.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalAtom.java index f9d39be68..bea9fc62c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalAtom.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.Arrays; import java.util.List; @@ -34,11 +34,11 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.VariableNormalizableAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.AbstractAtom; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.AbstractAtom; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalLiteral.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalLiteral.java similarity index 92% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalLiteral.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalLiteral.java index a0d762bf2..84f4d145d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/IntervalLiteral.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/IntervalLiteral.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.ArrayList; import java.util.Collections; @@ -36,13 +36,13 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.literals.FixedInterpretationLiteral; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.literals.AbstractLiteral; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.literals.AbstractLiteral; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/Literals.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/Literals.java similarity index 98% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/Literals.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/Literals.java index 8c34bb1b0..5409bce4a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/Literals.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/Literals.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; /** * Provides methods to convert atoms to literals and vice versa, diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtom.java similarity index 91% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtom.java index 605bc8dfb..582dd6510 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtom.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import java.util.Arrays; import java.util.Collections; @@ -36,12 +36,12 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Atoms corresponding to rule bodies use this predicate, first term is rule number, diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/CompiledRule.java similarity index 76% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/CompiledRule.java index b15dfbc41..c31ad509c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/CompiledRule.java @@ -1,9 +1,9 @@ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.core.programs.rules; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; public interface CompiledRule extends NormalRule { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java similarity index 93% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index ee2284f1d..9ffd78d07 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.rules; +package at.ac.tuwien.kr.alpha.core.programs.rules; import java.util.ArrayList; import java.util.List; @@ -36,13 +36,13 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.AbstractRule; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.rules.AbstractRule; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index fa1675a82..224d7cd70 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -8,19 +8,19 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 06ae095cd..c677bbc12 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -36,16 +36,16 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index eef4c6153..acdcd70ff 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -12,16 +12,16 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; /** * Rewrites the ordinary atom whose name is given in the input program by the enumeration directive #enum_atom_is into diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 7503e3d23..fcba9a331 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -38,17 +38,17 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.IntervalAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.core.programs.atoms.IntervalAtom; /** * Rewrites all interval terms in a rule into a new variable and an IntervalAtom. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java index a2f503ec2..b5d5dd6c8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java @@ -3,8 +3,8 @@ import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 86181b6ae..7a2ce7675 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -9,13 +9,13 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java index 0b7d4e7f1..5fc28c50a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; import at.ac.tuwien.kr.alpha.api.programs.Program; -import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; /** * Copyright (c) 2017-2019, the Alpha Team. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 9dfc543e2..34fed23dc 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -22,7 +22,7 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.depgraph.StratificationAlgorithm; @@ -36,7 +36,7 @@ import at.ac.tuwien.kr.alpha.core.grounder.instantiation.WorkingMemoryBasedInstantiationStrategy; import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Evaluates the stratifiable part of a given (analyzed) ASP program. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index d405a6bed..bdff508b4 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -41,14 +41,14 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.DisjunctiveHead; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.DisjunctiveHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java index f781b6f86..b959269d2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java @@ -10,11 +10,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; /** * Splits aggregate literals with both "lower" and "upper" bound operators into literals with only one operator each. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java index 51c3ae89d..9fd50cfc1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java @@ -10,16 +10,16 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java index f53c49113..70edf8f2e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java @@ -12,11 +12,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java index fa704b3ab..c7e3f2fc2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java @@ -21,13 +21,13 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** * Holds all information about aggregate literals that need to be rewritten within a program. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java index fd97d61be..1433f1665 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java @@ -13,11 +13,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; /** * Analyses a rule and records occurring aggregates and for each aggregate its global variables and its dependencies on diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index b2e32d02e..5c8ea4ed6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -13,15 +13,15 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.PredicateInternalizer; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 1af9a2711..9e22b5869 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -16,18 +16,18 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index 6b33ef17a..4672baa46 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -10,15 +10,15 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java index 0a12b8752..3995d6c27 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java @@ -7,13 +7,13 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/Choice.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/Choice.java index 10b398dda..8c50ee903 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/Choice.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/Choice.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.core.solver; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; class Choice { private final int atom; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManager.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManager.java index 8d8edcbb3..343fe2eab 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManager.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManager.java @@ -28,7 +28,7 @@ package at.ac.tuwien.kr.alpha.core.solver; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import java.util.ArrayList; import java.util.Collections; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java index b6d952e23..16c7f1e24 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java @@ -28,9 +28,9 @@ package at.ac.tuwien.kr.alpha.core.solver; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToNegatedLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToNegatedLiteral; import static at.ac.tuwien.kr.alpha.core.solver.NoGoodStore.LBD_NO_VALUE; import static at.ac.tuwien.kr.alpha.core.solver.heuristics.BranchingHeuristic.DEFAULT_CHOICE_LITERAL; import static at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult.UNSAT; @@ -57,13 +57,13 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.NoGood; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; import at.ac.tuwien.kr.alpha.core.grounder.ProgramAnalyzingGrounder; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.solver.heuristics.BranchingHeuristic; import at.ac.tuwien.kr.alpha.core.solver.heuristics.BranchingHeuristicFactory; import at.ac.tuwien.kr.alpha.core.solver.heuristics.ChainedBranchingHeuristics; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/LearnedNoGoodDeletion.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/LearnedNoGoodDeletion.java index f77211baa..d9f47d421 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/LearnedNoGoodDeletion.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/LearnedNoGoodDeletion.java @@ -5,7 +5,7 @@ import at.ac.tuwien.kr.alpha.core.common.Assignment; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.ArrayList; import java.util.Collections; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java index 7eb8bc6a2..ea86c4e44 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveNoGoodStore.java @@ -34,7 +34,7 @@ import java.util.HashMap; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.*; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.*; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.*; public class NaiveNoGoodStore implements NoGoodStore { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveSolver.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveSolver.java index 12507f071..3da723e59 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveSolver.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NaiveSolver.java @@ -27,9 +27,9 @@ */ package at.ac.tuwien.kr.alpha.core.solver; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isNegated; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; import static java.lang.Math.abs; import java.util.ArrayList; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java index 8b4d1977e..a33e8952a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java @@ -44,12 +44,12 @@ import static at.ac.tuwien.kr.alpha.commons.util.Util.arrayGrowthSize; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.literalToString; import static at.ac.tuwien.kr.alpha.core.common.NoGood.HEAD; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isNegated; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.literalToString; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.FALSE; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.MBT; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.TRUE; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java index 9194925d8..a972eab01 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java @@ -29,9 +29,9 @@ import static at.ac.tuwien.kr.alpha.commons.util.Util.arrayGrowthSize; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; import static at.ac.tuwien.kr.alpha.core.solver.Atoms.isAtom; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.FALSE; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.MBT; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WatchedNoGood.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WatchedNoGood.java index 50fde0e88..12f0c128a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WatchedNoGood.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WatchedNoGood.java @@ -33,7 +33,7 @@ import at.ac.tuwien.kr.alpha.core.common.NoGoodInterface; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.literalToString; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.literalToString; public final class WatchedNoGood implements NoGoodInterface, Antecedent { private int activity; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WritableAssignment.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WritableAssignment.java index 6ee85f3f7..f17d76277 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WritableAssignment.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/WritableAssignment.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.core.solver; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.NoGood; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaActiveRuleHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaActiveRuleHeuristic.java index f42aa1ee9..aae77b02d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaActiveRuleHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaActiveRuleHeuristic.java @@ -29,7 +29,7 @@ import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.heuristics.activity.BodyActivityProviderFactory.BodyActivityType; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.Random; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMin.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMin.java index 0581e6cca..ff1c65c7f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMin.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMin.java @@ -25,9 +25,9 @@ */ package at.ac.tuwien.kr.alpha.core.solver.heuristics; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.ThriceTruth; import at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult; @@ -38,8 +38,8 @@ import java.util.*; import java.util.stream.Stream; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.FALSE; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.TRUE; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMinLiteral.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMinLiteral.java index b523480bf..8a46227f6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMinLiteral.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BerkMinLiteral.java @@ -31,7 +31,7 @@ import at.ac.tuwien.kr.alpha.core.common.NoGood; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.Deque; import java.util.LinkedList; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BranchingHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BranchingHeuristic.java index 2e0bb219d..91a7524d1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BranchingHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/BranchingHeuristic.java @@ -28,7 +28,7 @@ import at.ac.tuwien.kr.alpha.core.common.NoGood; import at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import java.util.Collection; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/DependencyDrivenHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/DependencyDrivenHeuristic.java index 7d594fbcf..cd63b9a5c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/DependencyDrivenHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/DependencyDrivenHeuristic.java @@ -25,9 +25,9 @@ */ package at.ac.tuwien.kr.alpha.core.solver.heuristics; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.ThriceTruth; import at.ac.tuwien.kr.alpha.core.solver.heuristics.activity.BodyActivityProvider; @@ -44,7 +44,7 @@ import java.util.function.Predicate; import java.util.stream.Stream; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.*; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.*; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.FALSE; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.TRUE; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/GeneralizedDependencyDrivenHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/GeneralizedDependencyDrivenHeuristic.java index 9243c3589..4ebba14b3 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/GeneralizedDependencyDrivenHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/GeneralizedDependencyDrivenHeuristic.java @@ -30,7 +30,7 @@ import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.heuristics.activity.BodyActivityProviderFactory.BodyActivityType; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.HashSet; import java.util.Random; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtoms.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtoms.java index 94421084f..e73b40417 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtoms.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtoms.java @@ -35,7 +35,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.Arrays; import java.util.Collection; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveChoicePoints.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveChoicePoints.java index 24644e69b..17b09f1ac 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveChoicePoints.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveChoicePoints.java @@ -35,7 +35,7 @@ import java.util.Set; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; /** * Extends {@code HeapOfActiveAtoms} by a mechanism that, diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/NaiveHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/NaiveHeuristic.java index d77a7349f..73aaa986f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/NaiveHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/NaiveHeuristic.java @@ -31,7 +31,7 @@ import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import java.util.Collection; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristic.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristic.java index e2b2f3e2a..58d34938f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristic.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristic.java @@ -25,8 +25,8 @@ */ package at.ac.tuwien.kr.alpha.core.solver.heuristics; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDS.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDS.java index bb29d6e14..62286638c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDS.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDS.java @@ -26,9 +26,9 @@ package at.ac.tuwien.kr.alpha.core.solver.heuristics; import static at.ac.tuwien.kr.alpha.commons.util.Util.arrayGrowthSize; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; import java.util.ArrayList; import java.util.Arrays; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/activity/BodyActivityProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/activity/BodyActivityProvider.java index ff4503f9e..33b3257cc 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/activity/BodyActivityProvider.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/activity/BodyActivityProvider.java @@ -27,7 +27,7 @@ import org.apache.commons.collections4.MultiValuedMap; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import java.util.Map; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/learning/GroundConflictNoGoodLearner.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/learning/GroundConflictNoGoodLearner.java index 3224be049..68bb54701 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/learning/GroundConflictNoGoodLearner.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/learning/GroundConflictNoGoodLearner.java @@ -41,7 +41,7 @@ import java.util.stream.IntStream; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.*; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.*; import static at.ac.tuwien.kr.alpha.core.solver.NoGoodStore.LBD_NO_VALUE; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java index 40470cf09..8e202105e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java @@ -1,10 +1,10 @@ package at.ac.tuwien.kr.alpha.core.util; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramPartParser; public final class Substitutions { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/NoGoodTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/NoGoodTest.java index e448d058f..26b91aae7 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/NoGoodTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/NoGoodTest.java @@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; public class NoGoodTest { /** diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java index e54de4204..349249c17 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java @@ -8,12 +8,12 @@ import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Copyright (c) 2018, the Alpha Team. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibraryTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibraryTest.java index 2e2e954ce..474ad496c 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibraryTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/externals/AspStandardLibraryTest.java @@ -9,8 +9,8 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public class AspStandardLibraryTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java index 7b34de18c..530d54944 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/ChoiceGrounder.java @@ -50,22 +50,22 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java index c31821892..fe2cb6f8c 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/DummyGrounder.java @@ -51,21 +51,21 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Represents a small ASP program {@code { c :- a, b. a. b. }}. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorageTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorageTest.java index 8e29122e6..95f4491e4 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorageTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorageTest.java @@ -36,10 +36,10 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; /** * Copyright (c) 2016, the Alpha Team. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java index 4321d27da..1f1ca1d9b 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java @@ -47,10 +47,9 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; @@ -61,10 +60,11 @@ import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.solver.ThriceTruth; import at.ac.tuwien.kr.alpha.core.solver.TrailAssignment; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java index e5d44ded9..501978758 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java @@ -36,19 +36,19 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; /** * Tests {@link NoGoodGenerator} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderTest.java index b8964e9b6..a51bdd3a6 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleGroundingOrderTest.java @@ -43,8 +43,8 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramPartParser; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; /** * Copyright (c) 2017-2019, the Alpha Team. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java index 425511cc1..828f6f922 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/RuleToStringTest.java @@ -33,12 +33,12 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java index 3edc72515..fab449aea 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java @@ -38,23 +38,23 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.test.util.SubstitutionTestUtil; import at.ac.tuwien.kr.alpha.core.util.Substitutions; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnificationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnificationTest.java index 7492fc3d7..04bee51aa 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnificationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnificationTest.java @@ -7,8 +7,8 @@ import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramPartParser; /** diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java index d0a0aaf62..efae731d9 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java @@ -36,10 +36,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; public class UnifierTest extends SubstitutionTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationStrategyTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationStrategyTest.java index 6604e3300..397f0faa5 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationStrategyTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiationStrategyTest.java @@ -16,10 +16,10 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.NaiveGrounder; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiatorTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiatorTest.java index 5e3622252..337bb53f3 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiatorTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/instantiation/LiteralInstantiatorTest.java @@ -13,16 +13,16 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationLiteral; import at.ac.tuwien.kr.alpha.core.grounder.WorkingMemory; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationLiteral; public class LiteralInstantiatorTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustifiedTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustifiedTest.java index 87097ecad..cc069e529 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustifiedTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/structure/AnalyzeUnjustifiedTest.java @@ -44,8 +44,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.NaiveGrounder; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 08f95a453..4f037fda8 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -50,15 +50,15 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; /** diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/AtomsTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java similarity index 96% rename from alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/AtomsTest.java rename to alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java index 602bb960f..1c0c26b57 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/AtomsTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -20,8 +20,8 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/LiteralBindingNonBindingVariablesTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java similarity index 97% rename from alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/LiteralBindingNonBindingVariablesTest.java rename to alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java index 5b0370e9e..ae7589fc1 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/LiteralBindingNonBindingVariablesTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java @@ -23,7 +23,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -41,9 +41,9 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.IntPredicateInterpretation; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java index 17ade9d66..bc9789b4b 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java @@ -18,10 +18,10 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.ExternalLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java index b2450e02f..8715675b0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java @@ -22,8 +22,8 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java index 939bded78..76390be79 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java @@ -49,9 +49,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.externals.Externals; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplittingTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplittingTest.java index 4670282dd..13df2386e 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplittingTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplittingTest.java @@ -7,8 +7,8 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; public class AggregateLiteralSplittingTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalizationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalizationTest.java index 0461e9eea..3b8870c04 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalizationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalizationTest.java @@ -10,13 +10,13 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; public class AggregateOperatorNormalizationTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContextTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContextTest.java index b5603a9cf..969f26412 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContextTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContextTest.java @@ -13,11 +13,11 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java index a37c217d3..96a4c6e11 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java @@ -16,14 +16,14 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; public class AggregateRewritingRuleAnalysisTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingTest.java index d514d90bd..288b52fbd 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingTest.java @@ -17,8 +17,8 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java index 7e2adb491..96d0e0626 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java @@ -37,20 +37,20 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.ChoiceAtom; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; public class AtomCounterTests { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java index 0df75abb2..fe0bd40b0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java @@ -25,7 +25,7 @@ */ package at.ac.tuwien.kr.alpha.core.solver; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Collection; @@ -35,7 +35,6 @@ import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; @@ -44,6 +43,7 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; public class ChoiceManagerTests { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/HanoiTowerTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/HanoiTowerTest.java index 9083e3e6c..23457da10 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/HanoiTowerTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/HanoiTowerTest.java @@ -42,10 +42,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java index 911a2dd32..a592e870a 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java @@ -46,11 +46,11 @@ import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.ChoiceGrounder; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java index 2108b65db..7e21b6e72 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java @@ -38,10 +38,10 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java index d53a0b82d..9fb3cc9c4 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java @@ -41,10 +41,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java index 48603e2e8..1640e219e 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java @@ -39,10 +39,10 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.InputProgram; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java index b5c7516e0..a3bd04475 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java @@ -25,7 +25,7 @@ */ package at.ac.tuwien.kr.alpha.core.solver.heuristics; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtomsTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtomsTest.java index d0c5babe6..39a33527d 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtomsTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeapOfActiveAtomsTest.java @@ -31,10 +31,10 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.NoGoodStoreAlphaRoaming; import at.ac.tuwien.kr.alpha.core.solver.TrailAssignment; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeuristicTestUtils.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeuristicTestUtils.java index 0a6606e15..ce4b7d8ad 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeuristicTestUtils.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/HeuristicTestUtils.java @@ -29,9 +29,9 @@ import java.util.Collection; import java.util.HashSet; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.NoGoodStoreAlphaRoaming; import at.ac.tuwien.kr.alpha.core.solver.WritableAssignment; import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristicTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristicTest.java index 4af6a0e77..1b2d98150 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristicTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/ReplayHeuristicTest.java @@ -25,7 +25,7 @@ */ package at.ac.tuwien.kr.alpha.core.solver.heuristics; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDSTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDSTest.java index aa18db17f..7e2bd1eaf 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDSTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/VSIDSTest.java @@ -34,10 +34,10 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.core.atoms.Literals; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; +import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.solver.NoGoodStoreAlphaRoaming; import at.ac.tuwien.kr.alpha.core.solver.TrailAssignment; import at.ac.tuwien.kr.alpha.core.solver.WritableAssignment; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/RuleParser.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/RuleParser.java index 38da4d36d..5381de504 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/RuleParser.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/RuleParser.java @@ -2,8 +2,8 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; public class RuleParser { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/SubstitutionTestUtil.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/SubstitutionTestUtil.java index 9da1d7f24..61055d5c2 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/SubstitutionTestUtil.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/SubstitutionTestUtil.java @@ -31,7 +31,7 @@ import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; public class SubstitutionTestUtil { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/TestUtils.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/TestUtils.java index 75cbc20df..bd0c358c1 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/TestUtils.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/test/util/TestUtils.java @@ -29,10 +29,10 @@ import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 28e5cceef..d21d8986c 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -62,7 +62,7 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.programs.Reifier; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.common.AtomStore; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 1606f792b..0cd3ad1e8 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -65,14 +65,16 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.BasicRule; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.MethodPredicateInterpretation; import at.ac.tuwien.kr.alpha.core.externals.AspStandardLibrary; import at.ac.tuwien.kr.alpha.core.externals.Externals; @@ -316,7 +318,7 @@ private static class SubThingy extends Thingy { public void withExternalSubtype() throws Exception { SubThingy thingy = new SubThingy(); - BasicRule rule = new BasicRule( + Rule rule = Rules.newRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newConstant("x"))), singletonList(Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("thinger", 1), new MethodPredicateInterpretation(this.getClass().getMethod("thinger", Thingy.class)), singletonList(Terms.newConstant(thingy)), diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/FixedInterpretationLiteralsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/FixedInterpretationLiteralsTest.java index 6d236e447..690e39777 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/FixedInterpretationLiteralsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/FixedInterpretationLiteralsTest.java @@ -19,10 +19,10 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.externals.AspStandardLibrary; import at.ac.tuwien.kr.alpha.core.externals.Externals; From 50bdc422d5353be747740fcaeb0d2d1335b6472b Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 15:11:58 +0200 Subject: [PATCH 43/96] code cleanup - move ASPCore2Program to commons module --- .../commons/programs/ASPCore2ProgramImpl.java | 72 ++------------- .../commons}/programs/AbstractProgram.java | 2 +- .../programs}/InlineDirectivesImpl.java | 2 +- .../commons}/programs/NormalProgramImpl.java | 2 +- .../kr/alpha/commons/programs/Programs.java | 87 +++++++++++++++++++ .../alpha/core/parser/ParseTreeVisitor.java | 17 ++-- .../alpha/core/parser/ProgramParserImpl.java | 7 +- .../alpha/core/programs/InternalProgram.java | 2 + .../kr/alpha/core/programs/Programs.java | 24 ----- .../ArithmeticTermsRewriting.java | 2 +- .../transformation/ChoiceHeadToNormal.java | 7 +- .../transformation/EnumerationRewriting.java | 7 +- .../IntervalTermToIntervalAtom.java | 2 +- .../NormalizeProgramTransformation.java | 2 +- .../transformation/PredicateInternalizer.java | 5 +- .../VariableEqualityRemoval.java | 4 +- .../AggregateOperatorNormalization.java | 3 +- .../aggregates/AggregateRewriting.java | 5 +- .../encoders/AbstractAggregateEncoder.java | 11 +-- .../aggregates/encoders/MinMaxEncoder.java | 5 +- .../StringtemplateBasedAggregateEncoder.java | 8 +- .../ArithmeticTermsRewritingTest.java | 2 +- .../ProgramTransformationTest.java | 2 +- .../StratifiedEvaluationTest.java | 3 +- .../kr/alpha/core/solver/SolverTests.java | 7 +- .../solver/ThreeColouringRandomGraphTest.java | 9 +- .../solver/ThreeColouringTestWithRandom.java | 7 +- .../core/solver/ThreeColouringWheelTest.java | 9 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 7 +- .../kr/alpha/api/impl/AlphaImplTest.java | 13 +-- 30 files changed, 176 insertions(+), 159 deletions(-) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java (53%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/programs/AbstractProgram.java (97%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs}/InlineDirectivesImpl.java (95%) rename {alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core => alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons}/programs/NormalProgramImpl.java (96%) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java similarity index 53% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java index 9711a1e89..6369053ac 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InputProgram.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.programs; +package at.ac.tuwien.kr.alpha.commons.programs; import java.util.ArrayList; import java.util.Collections; @@ -36,84 +36,22 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; /** * Alpha-internal representation of an ASP program, i.e., a set of ASP rules. *

* Copyright (c) 2017-2019, the Alpha Team. */ -public class InputProgram extends AbstractProgram> implements ASPCore2Program{ +class ASPCore2ProgramImpl extends AbstractProgram> implements ASPCore2Program{ - public static final InputProgram EMPTY = new InputProgram(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl()); + static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl()); - public InputProgram(List> rules, List facts, InlineDirectives inlineDirectives) { + ASPCore2ProgramImpl(List> rules, List facts, InlineDirectives inlineDirectives) { super(rules, facts, inlineDirectives); } - public InputProgram() { + ASPCore2ProgramImpl() { super(new ArrayList<>(), new ArrayList<>(), new InlineDirectivesImpl()); } - public static Builder builder() { - return new Builder(); - } - - public static Builder builder(ASPCore2Program prog) { - return new Builder(prog); - } - - /** - * Builder for more complex program construction scenarios, ensuring that an {@link InputProgram} is immutable - */ - public static class Builder { - - private List> rules = new ArrayList<>(); - private List facts = new ArrayList<>(); - private InlineDirectives inlineDirectives = new InlineDirectivesImpl(); - - public Builder(ASPCore2Program prog) { - this.addRules(prog.getRules()); - this.addFacts(prog.getFacts()); - this.addInlineDirectives(prog.getInlineDirectives()); - } - - public Builder() { - - } - - public Builder addRules(List> rules) { - this.rules.addAll(rules); - return this; - } - - public Builder addRule(Rule r) { - this.rules.add(r); - return this; - } - - public Builder addFacts(List facts) { - this.facts.addAll(facts); - return this; - } - - public Builder addFact(Atom fact) { - this.facts.add(fact); - return this; - } - - public Builder addInlineDirectives(InlineDirectives inlineDirectives) { - this.inlineDirectives.accumulate(inlineDirectives); - return this; - } - - public Builder accumulate(ASPCore2Program prog) { - return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()); - } - - public InputProgram build() { - return new InputProgram(this.rules, this.facts, this.inlineDirectives); - } - } - } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java similarity index 97% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java index 619e76948..f78ee2e80 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/AbstractProgram.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs; +package at.ac.tuwien.kr.alpha.commons.programs; import java.util.Collections; import java.util.List; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/InlineDirectivesImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java similarity index 95% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/InlineDirectivesImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java index c04de330c..89c768a58 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/InlineDirectivesImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.parser; +package at.ac.tuwien.kr.alpha.commons.programs; import java.util.LinkedHashMap; import java.util.Map; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java similarity index 96% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java index c708509b9..8f68852e5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/NormalProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs; +package at.ac.tuwien.kr.alpha.commons.programs; import java.util.ArrayList; import java.util.List; diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java new file mode 100644 index 000000000..d2f00a657 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -0,0 +1,87 @@ +package at.ac.tuwien.kr.alpha.commons.programs; + +import java.util.ArrayList; +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; + +public final class Programs { + + private Programs() { + throw new AssertionError("Cannot instantiate utility class!"); + } + + public static ASPCore2Program emptyProgram() { + return ASPCore2ProgramImpl.EMPTY; + } + + public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { + return new ASPCore2ProgramImpl(rules, facts, inlineDirectives); + } + + public static ASPCore2ProgramBuilder builder() { + return new ASPCore2ProgramBuilder(); + } + + public static ASPCore2ProgramBuilder builder(ASPCore2Program program) { + return new ASPCore2ProgramBuilder(program); + } + + /** + * Builder for more complex program construction scenarios, ensuring that an {@link AspCore2ProgramImpl} is immutable + */ + public static class ASPCore2ProgramBuilder { + + private List> rules = new ArrayList<>(); + private List facts = new ArrayList<>(); + private InlineDirectives inlineDirectives = new InlineDirectivesImpl(); + + public ASPCore2ProgramBuilder(ASPCore2Program prog) { + this.addRules(prog.getRules()); + this.addFacts(prog.getFacts()); + this.addInlineDirectives(prog.getInlineDirectives()); + } + + public ASPCore2ProgramBuilder() { + + } + + public ASPCore2ProgramBuilder addRules(List> rules) { + this.rules.addAll(rules); + return this; + } + + public ASPCore2ProgramBuilder addRule(Rule r) { + this.rules.add(r); + return this; + } + + public ASPCore2ProgramBuilder addFacts(List facts) { + this.facts.addAll(facts); + return this; + } + + public ASPCore2ProgramBuilder addFact(Atom fact) { + this.facts.add(fact); + return this; + } + + public ASPCore2ProgramBuilder addInlineDirectives(InlineDirectives inlineDirectives) { + this.inlineDirectives.accumulate(inlineDirectives); + return this; + } + + public ASPCore2ProgramBuilder accumulate(ASPCore2Program prog) { + return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()); + } + + public ASPCore2Program build() { + return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives); + } + } + +} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 5a396e423..98894ef1b 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -43,6 +43,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; @@ -53,9 +54,9 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; @@ -65,6 +66,9 @@ import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -72,7 +76,6 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * Copyright (c) 2016-2018, the Alpha Team. @@ -81,7 +84,7 @@ public class ParseTreeVisitor extends ASPCore2BaseVisitor { private final Map externals; private final boolean acceptVariables; - private InputProgram.Builder programBuilder; + private ASPCore2ProgramBuilder programBuilder; private InlineDirectives inlineDirectives; public ParseTreeVisitor(Map externals) { @@ -100,7 +103,7 @@ private UnsupportedOperationException notSupported(RuleContext ctx) { /** * Translates a program context (referring to a node in an ATN specific to ANTLR) to the internal representation of Alpha. */ - public InputProgram translate(ASPCore2Parser.ProgramContext input) { + public ASPCore2Program translate(ASPCore2Parser.ProgramContext input) { return visitProgram(input); } @@ -150,17 +153,17 @@ public String visitTerminal(TerminalNode node) { } @Override - public InputProgram visitProgram(ASPCore2Parser.ProgramContext ctx) { + public ASPCore2Program visitProgram(ASPCore2Parser.ProgramContext ctx) { // program : statements? query?; if (ctx.query() != null) { throw notSupported(ctx.query()); } if (ctx.statements() == null) { - return InputProgram.EMPTY; + return Programs.emptyProgram(); } inlineDirectives = new InlineDirectivesImpl(); - programBuilder = InputProgram.builder(); + programBuilder = Programs.builder(); visitStatements(ctx.statements()); programBuilder.addInlineDirectives(inlineDirectives); return programBuilder.build(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java index 2b7d82905..cc63f903d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java @@ -19,10 +19,11 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.externals.Externals; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; public class ProgramParserImpl implements ProgramParser { @@ -142,7 +143,7 @@ public ASPCore2Program parse(Path programPath, Map externalPredicateDefinitions, Path... programSources) throws IOException { - InputProgram.Builder bld = InputProgram.builder(); + ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); } @@ -151,7 +152,7 @@ public ASPCore2Program parse(Map externalPredic @Override public ASPCore2Program parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { - InputProgram.Builder bld = InputProgram.builder(); + ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index ff98ee41b..2c6ae6677 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -15,6 +15,8 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.commons.programs.AbstractProgram; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.grounder.FactIntervalEvaluator; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java deleted file mode 100644 index e467c657f..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/Programs.java +++ /dev/null @@ -1,24 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs; - -import java.io.IOException; -import java.io.InputStream; -import java.util.Map; - -import org.antlr.v4.runtime.CharStreams; - -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; - -public class Programs { - - private Programs() { - throw new AssertionError("This is a pure utility class and should therefore not be instantiated!"); - } - - public static ASPCore2Program fromInputStream(InputStream is, Map externals) throws IOException { - ProgramParserImpl parser = new ProgramParserImpl(); - return parser.parse(CharStreams.fromStream(is), externals); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index 224d7cd70..563c7787d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -17,12 +17,12 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; /** * Transforms rules such that arithmetic terms only occur in comparison predicates. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index c677bbc12..5783dd2d9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -38,15 +38,16 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * Copyright (c) 2017-2021, the Alpha Team. @@ -57,7 +58,7 @@ public class ChoiceHeadToNormal extends ProgramTransformation> additionalRules = new ArrayList<>(); List> srcRules = new ArrayList<>(inputProgram.getRules()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index acdcd70ff..b3b01431c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -18,9 +18,10 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; /** @@ -42,7 +43,7 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { } Predicate enumPredicate = Predicates.getPredicate(enumDirective, 3); - InputProgram.Builder programBuilder = InputProgram.builder().addInlineDirectives(inputProgram.getInlineDirectives()); + ASPCore2ProgramBuilder programBuilder = Programs.builder().addInlineDirectives(inputProgram.getInlineDirectives()); checkFactsAreEnumerationFree(inputProgram.getFacts(), enumPredicate); programBuilder.addFacts(inputProgram.getFacts()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index fcba9a331..5912d597c 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -44,10 +44,10 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.atoms.IntervalAtom; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java index b5d5dd6c8..3d26dec22 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java @@ -3,7 +3,7 @@ import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 7a2ce7675..23b47bc83 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -13,10 +13,11 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * @@ -27,7 +28,7 @@ public class PredicateInternalizer { public static ASPCore2Program makePrefixedPredicatesInternal(ASPCore2Program program, String prefix) { - InputProgram.Builder prgBuilder = InputProgram.builder(); + ASPCore2ProgramBuilder prgBuilder = Programs.builder(); for (Atom atom : program.getFacts()) { if (atom.getPredicate().getName().startsWith(prefix)) { prgBuilder.addFact(PredicateInternalizer.makePredicateInternal((BasicAtom) atom)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index bdff508b4..3c84b54a0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -47,10 +47,10 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * Removes variable equalities from rules by replacing one variable with the other. @@ -65,7 +65,7 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { for (Rule rule : inputProgram.getRules()) { rewrittenRules.add(findAndReplaceVariableEquality(rule)); } - return new InputProgram(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); + return Programs.newASPCore2Program(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } private Rule findAndReplaceVariableEquality(Rule rule) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java index 9fd50cfc1..12e3273b6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java @@ -20,10 +20,9 @@ import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** - * Transforms an {@link InputProgram} such that, for all aggregate (body-)literals, only the comparison operators "=" + * Transforms an {@link AspCore2ProgramImpl} such that, for all aggregate (body-)literals, only the comparison operators "=" * and "<=" are used. * * Rewriting of "#count" and "#sum" aggregates is done using the following equivalences: diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java index 70edf8f2e..aff59e893 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java @@ -15,9 +15,10 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AbstractAggregateEncoder; @@ -88,7 +89,7 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { } // Substitute AggregateLiterals with generated result literals. outputRules.addAll(rewriteRulesWithAggregates(ctx)); - InputProgram.Builder resultBuilder = InputProgram.builder().addRules(outputRules).addFacts(inputProgram.getFacts()) + ASPCore2ProgramBuilder resultBuilder = Programs.builder().addRules(outputRules).addFacts(inputProgram.getFacts()) .addInlineDirectives(inputProgram.getInlineDirectives()); // Add sub-programs deriving respective aggregate literals. for (Map.Entry, Set> aggToRewrite : ctx.getAggregateFunctionsToRewrite() diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index 5c8ea4ed6..36cead4b7 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -18,12 +18,13 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.PredicateInternalizer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -49,10 +50,10 @@ protected AbstractAggregateEncoder(AggregateFunctionSymbol aggregateFunctionToEn * Encodes all aggregate literals in the given set of aggregate referenced by the given {@link AggregateInfo}. * * @param aggregatesToEncode the aggregates to encode. - * @return all rules encoding the given aggregates as an {@link InputProgram}. + * @return all rules encoding the given aggregates as an {@link AspCore2ProgramImpl}. */ public ASPCore2Program encodeAggregateLiterals(Set aggregatesToEncode) { - InputProgram.Builder programBuilder = InputProgram.builder(); + ASPCore2ProgramBuilder programBuilder = Programs.builder(); for (AggregateInfo aggregateInfo : aggregatesToEncode) { programBuilder.accumulate(encodeAggregateLiteral(aggregateInfo)); } @@ -82,7 +83,7 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { Rule elementRule = encodeAggregateElement(aggregateToEncode, elementToEncode); elementEncodingRules.add(PredicateInternalizer.makePrefixedPredicatesInternal(elementRule, aggregateId)); } - return new InputProgram(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), new InlineDirectivesImpl()); + return Programs.newASPCore2Program(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), new InlineDirectivesImpl()); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 9e22b5869..179014554 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -23,6 +23,8 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -30,7 +32,6 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; public class MinMaxEncoder extends AbstractAggregateEncoder { @@ -120,7 +121,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) resultRuleBody.add(aggregateResult); resultRuleBody.add(aggregateValueComparison); resultRuleBody.addAll(aggregateToEncode.getDependencies()); - InputProgram.Builder bld = InputProgram.builder(parser.parse(encodingTemplate.render())); + ASPCore2ProgramBuilder bld = Programs.builder(parser.parse(encodingTemplate.render())); Rule resultRule = Rules.newRule(resultRuleHead, resultRuleBody); bld.addRule(resultRule); return bld.build(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index 4672baa46..33daaceb4 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -10,18 +10,18 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationRewriting; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; @@ -85,7 +85,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) ASPCore2Program coreEncoding = new EnumerationRewriting().apply(parser.parse(coreEncodingAsp)); // Add the programatically created bound rule and return - return new InputProgram(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), + return Programs.newASPCore2Program(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), new InlineDirectivesImpl()); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java index bc9789b4b..85aaff83b 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java @@ -21,10 +21,10 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; /** * Copyright (c) 2021, the Alpha Team. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index f11692dcf..2c2ac4207 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -15,9 +15,9 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; public class ProgramTransformationTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java index 76390be79..2cf6b1337 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationTest.java @@ -61,7 +61,6 @@ import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.Programs; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; @@ -201,7 +200,7 @@ public void testNegatedLiteralInRecursiveRule() throws IOException { + "inc_value(4), inc_value(5), inc_value(6), inc_value(7), " + "inc_value(8)"; //@formatter:on - ASPCore2Program prog = Programs.fromInputStream( + ASPCore2Program prog = new ProgramParserImpl().parse( StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/recursive_w_negated_condition.asp"), new HashMap<>()); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java index a592e870a..52b67afbb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java @@ -44,19 +44,20 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.ChoiceGrounder; import at.ac.tuwien.kr.alpha.core.grounder.DummyGrounder; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.test.util.AnswerSetsParser; public class SolverTests { @@ -79,7 +80,7 @@ public void testObjectProgram(RegressionTestConfig cfg) { final Atom fact = Atoms.newBasicAtom(Predicates.getPredicate("foo", 1), Terms.newConstant(thingy)); - final InputProgram program = new InputProgram( + final ASPCore2Program program = Programs.newASPCore2Program( Collections.emptyList(), Collections.singletonList(fact), new InlineDirectivesImpl() diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java index 7e21b6e72..b39232c8c 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringRandomGraphTest.java @@ -40,10 +40,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; public class ThreeColouringRandomGraphTest { @@ -105,10 +106,10 @@ private void testThreeColouring(int nVertices, int nEdges, RegressionTestConfig ":- e(N1,N2), blue(N1), blue(N2)." + ":- e(N1,N2), red(N1), red(N2)." + ":- e(N1,N2), green(N1), green(N2)."); - InputProgram.Builder prgBuilder = InputProgram.builder(tmpPrg); + ASPCore2ProgramBuilder prgBuilder = Programs.builder(tmpPrg); prgBuilder.addFacts(createVertices(nVertices)); prgBuilder.addFacts(createEdges(nVertices, nEdges)); - InputProgram program = prgBuilder.build(); + ASPCore2Program program = prgBuilder.build(); maybeShuffle(program); @SuppressWarnings("unused") @@ -119,7 +120,7 @@ private void testThreeColouring(int nVertices, int nEdges, RegressionTestConfig } @SuppressWarnings("unused") - private void maybeShuffle(InputProgram program) { + private void maybeShuffle(ASPCore2Program program) { // TODO: switch on if different rule orderings in the encoding are desired (e.g. for benchmarking purposes) // FIXME since InputProgram is immutable this needs to be reworked a bit if used diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java index 9fb3cc9c4..e0ff335a6 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringTestWithRandom.java @@ -43,10 +43,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * Tests {@link AbstractSolver} using some three-coloring test cases, as described in: @@ -186,11 +187,11 @@ public void testN101(RegressionTestConfig cfg) { private void testThreeColouring(int n, boolean shuffle, int seed, RegressionTestConfig cfg) { ASPCore2Program tmpPrg = new ProgramParserImpl() .parse("col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); - InputProgram.Builder prgBuilder = InputProgram.builder().accumulate(tmpPrg); + ASPCore2ProgramBuilder prgBuilder = Programs.builder().accumulate(tmpPrg); prgBuilder.addFacts(createColors("1", "2", "3")); prgBuilder.addFacts(createVertices(n)); prgBuilder.addFacts(createEdges(n, shuffle, seed)); - InputProgram program = prgBuilder.build(); + ASPCore2Program program = prgBuilder.build(); Solver solver = buildSolverForRegressionTest(program, cfg); @SuppressWarnings("unused") diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java index 1640e219e..370e6fbd0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ThreeColouringWheelTest.java @@ -41,10 +41,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; /** * Tests {@link AbstractSolver} using some three-coloring test cases, as described in: @@ -102,11 +103,11 @@ private void testThreeColouring(int n, RegressionTestConfig cfg) { "col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); - InputProgram.Builder prgBuilder = InputProgram.builder(tmpPrg); + ASPCore2ProgramBuilder prgBuilder = Programs.builder(tmpPrg); prgBuilder.addFacts(createColors("red", "blue", "green")); prgBuilder.addFacts(createVertices(n)); prgBuilder.addFacts(createEdges(n)); - InputProgram program = prgBuilder.build(); + ASPCore2Program program = prgBuilder.build(); maybeShuffle(program); @@ -120,7 +121,7 @@ private void testThreeColouring(int n, RegressionTestConfig cfg) { } @SuppressWarnings("unused") - private void maybeShuffle(InputProgram program) { + private void maybeShuffle(ASPCore2Program program) { // FIXME since InputProgram is immutable this needs to be reworked a bit if used // No shuffling here. } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index d21d8986c..4c8c21b0b 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -61,6 +61,8 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.Reifier; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; @@ -72,7 +74,6 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; @@ -94,7 +95,7 @@ public AlphaImpl() { @Override public ASPCore2Program readProgram(InputConfig cfg) throws IOException { - InputProgram.Builder prgBuilder = InputProgram.builder(); + ASPCore2ProgramBuilder prgBuilder = Programs.builder(); ASPCore2Program tmpProg; if (!cfg.getFiles().isEmpty()) { tmpProg = readProgramFiles(cfg.isLiterate(), cfg.getPredicateMethods(), cfg.getFiles()); @@ -114,7 +115,7 @@ public ASPCore2Program readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException { - InputProgram.Builder prgBuilder = InputProgram.builder(); + ASPCore2ProgramBuilder prgBuilder = Programs.builder(); ASPCore2Program tmpProg; for (Path path : paths) { InputStream stream; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 0cd3ad1e8..7bf9a8e8a 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -70,6 +70,9 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -78,10 +81,8 @@ import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.MethodPredicateInterpretation; import at.ac.tuwien.kr.alpha.core.externals.AspStandardLibrary; import at.ac.tuwien.kr.alpha.core.externals.Externals; -import at.ac.tuwien.kr.alpha.core.parser.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InputProgram; public class AlphaImplTest { @@ -151,7 +152,7 @@ public void addsFacts() { Thingy a = new Thingy(); Thingy b = new Thingy(); List things = asList(a, b); - InputProgram program = InputProgram.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); + ASPCore2Program program = Programs.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); Set actual = system.solve(program).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build())); assertEquals(expected, actual); @@ -326,7 +327,7 @@ public void withExternalSubtype() throws Exception { Alpha system = new AlphaImpl(); - InputProgram prog = new InputProgram(singletonList(rule), emptyList(), new InlineDirectivesImpl()); + ASPCore2Program prog = Programs.newASPCore2Program(singletonList(rule), emptyList(), new InlineDirectivesImpl()); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").instance("x").build())); @@ -629,11 +630,11 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep @Test public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { final ProgramParser parser = new ProgramParserImpl(); - InputProgram.Builder bld = InputProgram.builder(); + ASPCore2ProgramBuilder bld = Programs.builder(); bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), StandardOpenOption.READ))); bld.accumulate( parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); - InputProgram parsedProgram = bld.build(); + ASPCore2Program parsedProgram = bld.build(); SystemConfig config = new SystemConfig(); config.setSolverName("default"); From dfcda1bb104d7b84630dd5d86fe30cea307a2842 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 15:59:34 +0200 Subject: [PATCH 44/96] code cleanup - move NormalProgramImpl and InlineDirectivesImpl to commons module --- .../programs/InlineDirectivesImpl.java | 2 +- .../commons/programs/NormalProgramImpl.java | 17 ++-------------- .../kr/alpha/commons/programs/Programs.java | 20 +++++++++++++++++++ .../alpha/core/parser/ParseTreeVisitor.java | 3 +-- .../alpha/core/programs/InternalProgram.java | 4 ++-- .../ArithmeticTermsRewriting.java | 4 ++-- .../transformation/EnumerationRewriting.java | 13 ++++++------ .../IntervalTermToIntervalAtom.java | 4 ++-- .../NormalizeProgramTransformation.java | 4 ++-- .../encoders/AbstractAggregateEncoder.java | 3 +-- .../StringtemplateBasedAggregateEncoder.java | 3 +-- .../ArithmeticTermsRewritingTest.java | 6 +++--- .../ProgramTransformationTest.java | 8 ++++---- .../kr/alpha/core/solver/SolverTests.java | 3 +-- .../kr/alpha/api/impl/AlphaImplTest.java | 3 +-- 15 files changed, 49 insertions(+), 48 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java index 89c768a58..be34d2022 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InlineDirectivesImpl.java @@ -9,7 +9,7 @@ * Stores directives appearing in the ASP program. Each directive starts with # and ends with . * Copyright (c) 2017 - 2021, the Alpha Team. */ -public class InlineDirectivesImpl implements InlineDirectives { +class InlineDirectivesImpl implements InlineDirectives { private final LinkedHashMap directives = new LinkedHashMap<>(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java index 8f68852e5..8bbfc4365 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/NormalProgramImpl.java @@ -1,34 +1,21 @@ package at.ac.tuwien.kr.alpha.commons.programs; -import java.util.ArrayList; import java.util.List; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; /** * A program that only contains NormalRules. * * Copyright (c) 2019, the Alpha Team. */ -public class NormalProgramImpl extends AbstractProgram implements NormalProgram { +class NormalProgramImpl extends AbstractProgram implements NormalProgram { - public NormalProgramImpl(List rules, List facts, InlineDirectives inlineDirectives) { + NormalProgramImpl(List rules, List facts, InlineDirectives inlineDirectives) { super(rules, facts, inlineDirectives); } - public static NormalProgramImpl fromInputProgram(ASPCore2Program inputProgram) { - List normalRules = new ArrayList<>(); - for (Rule r : inputProgram.getRules()) { - normalRules.add(Rules.toNormalRule(r)); - } - return new NormalProgramImpl(normalRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); - } - } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java index d2f00a657..2bafac832 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -5,9 +5,12 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; public final class Programs { @@ -31,6 +34,22 @@ public static ASPCore2ProgramBuilder builder(ASPCore2Program program) { return new ASPCore2ProgramBuilder(program); } + public static NormalProgram newNormalProgram(List rules, List facts, InlineDirectives inlineDirectives) { + return new NormalProgramImpl(rules, facts, inlineDirectives); + } + + public static NormalProgram toNormalProgram(ASPCore2Program inputProgram) { + List normalRules = new ArrayList<>(); + for (Rule r : inputProgram.getRules()) { + normalRules.add(Rules.toNormalRule(r)); + } + return new NormalProgramImpl(normalRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); + } + + public static InlineDirectives newInlineDirectives() { + return new InlineDirectivesImpl(); + } + /** * Builder for more complex program construction scenarios, ensuring that an {@link AspCore2ProgramImpl} is immutable */ @@ -82,6 +101,7 @@ public ASPCore2ProgramBuilder accumulate(ASPCore2Program prog) { public ASPCore2Program build() { return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives); } + } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 98894ef1b..5d77e587d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -66,7 +66,6 @@ import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; @@ -162,7 +161,7 @@ public ASPCore2Program visitProgram(ASPCore2Parser.ProgramContext ctx) { if (ctx.statements() == null) { return Programs.emptyProgram(); } - inlineDirectives = new InlineDirectivesImpl(); + inlineDirectives = Programs.newInlineDirectives(); programBuilder = Programs.builder(); visitStatements(ctx.statements()); programBuilder.addInlineDirectives(inlineDirectives); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index 2c6ae6677..43e69b984 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -16,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.programs.AbstractProgram; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.grounder.FactIntervalEvaluator; @@ -106,7 +106,7 @@ public NormalProgram toNormalProgram() { for (CompiledRule rule : getRules()) { normalRules.add(Rules.newNormalRule(rule.getHead(), new ArrayList<>(rule.getBody()))); } - return new NormalProgramImpl(normalRules, getFacts(), getInlineDirectives()); + return Programs.newNormalProgram(normalRules, getFacts(), getInlineDirectives()); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index 563c7787d..b556c642a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -17,7 +17,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; @@ -52,7 +52,7 @@ public NormalProgram apply(NormalProgram inputProgram) { return inputProgram; } // Create new program with rewritten rules. - return new NormalProgramImpl(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); + return Programs.newNormalProgram(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index b3b01431c..9d20fb69f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -1,13 +1,12 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; - import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; @@ -18,10 +17,10 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; /** @@ -36,7 +35,7 @@ public class EnumerationRewriting extends ProgramTransformation srcFacts, Predicate enumPredicate) { for (Atom fact : srcFacts) { if (fact.getPredicate().equals(enumPredicate)) { - throw oops("Atom declared as enumeration atom by directive occurs in a fact: " + fact); + throw Util.oops("Atom declared as enumeration atom by directive occurs in a fact: " + fact); } } } @@ -65,10 +64,10 @@ private List> rewriteRules(List> srcRules, Predicate enumP List> rewrittenRules = new ArrayList<>(); for (Rule rule : srcRules) { if (rule.getHead() != null && !(rule.getHead() instanceof NormalHead)) { - throw oops("Encountered rule whose head is not normal: " + rule); + throw Util.oops("Encountered rule whose head is not normal: " + rule); } if (rule.getHead() != null && ((NormalHead) rule.getHead()).getAtom().getPredicate().equals(enumPredicate)) { - throw oops("Atom declared as enumeration atom by directive occurs in head of the rule: " + rule); + throw Util.oops("Atom declared as enumeration atom by directive occurs in head of the rule: " + rule); } List modifiedBodyLiterals = new ArrayList<>(rule.getBody()); Iterator rit = modifiedBodyLiterals.iterator(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 5912d597c..90d532aff 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -44,7 +44,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; @@ -182,6 +182,6 @@ public NormalProgram apply(NormalProgram inputProgram) { if (!didChange) { return inputProgram; } - return new NormalProgramImpl(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); + return Programs.newNormalProgram(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java index 3d26dec22..f8d3303f0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java @@ -3,7 +3,7 @@ import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewriting; @@ -34,7 +34,7 @@ public NormalProgram apply(ASPCore2Program inputProgram) { EnumerationAtom.resetEnumerations(); // Construct the normal program. - NormalProgram retVal = NormalProgramImpl.fromInputProgram(tmpPrg); + NormalProgram retVal = Programs.toNormalProgram(tmpPrg); // Transform intervals. retVal = new IntervalTermToIntervalAtom().apply(retVal); // Rewrite ArithmeticTerms. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index 36cead4b7..4b6c431b1 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -18,7 +18,6 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; @@ -83,7 +82,7 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { Rule elementRule = encodeAggregateElement(aggregateToEncode, elementToEncode); elementEncodingRules.add(PredicateInternalizer.makePrefixedPredicatesInternal(elementRule, aggregateId)); } - return Programs.newASPCore2Program(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), new InlineDirectivesImpl()); + return Programs.newASPCore2Program(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), Programs.newInlineDirectives()); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index 33daaceb4..8869c66fe 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -15,7 +15,6 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -86,7 +85,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) // Add the programatically created bound rule and return return Programs.newASPCore2Program(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), - new InlineDirectivesImpl()); + Programs.newInlineDirectives()); } private String getBoundPredicateName(String aggregateId) { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java index 85aaff83b..e92589302 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewritingTest.java @@ -21,7 +21,7 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -43,7 +43,7 @@ public static Set>> externalForArithmeticTermsRewriti @Test public void rewriteRule() { - NormalProgram inputProgram = NormalProgramImpl.fromInputProgram(parser.parse("p(X+1) :- q(Y/2), r(f(X*2),Y), X-2 = Y*3, X = 0..9.")); + NormalProgram inputProgram = Programs.toNormalProgram(parser.parse("p(X+1) :- q(Y/2), r(f(X*2),Y), X-2 = Y*3, X = 0..9.")); assertEquals(1, inputProgram.getRules().size()); ArithmeticTermsRewriting arithmeticTermsRewriting = new ArithmeticTermsRewriting(); NormalProgram rewrittenProgram = arithmeticTermsRewriting.apply(inputProgram); @@ -56,7 +56,7 @@ public void rewriteRule() { @Test public void rewriteExternalAtom() { - NormalProgram inputProgram = NormalProgramImpl.fromInputProgram(parser.parse("p :- Y = 13, &extArithTest[Y*5](Y-4).")); + NormalProgram inputProgram = Programs.toNormalProgram(parser.parse("p :- Y = 13, &extArithTest[Y*5](Y-4).")); assertEquals(1, inputProgram.getRules().size()); ArithmeticTermsRewriting arithmeticTermsRewriting = new ArithmeticTermsRewriting(); NormalProgram rewrittenProgram = arithmeticTermsRewriting.apply(inputProgram); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index 2c2ac4207..d7ff68a37 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -15,7 +15,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.commons.programs.NormalProgramImpl; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -67,17 +67,17 @@ public void choiceHeadToNormalSimpleTest() { @Test public void intervalTermToIntervalAtomSimpleTest() { - genericTransformationTest(intervalRewriting, NormalProgramImpl::fromInputProgram, "interval.1"); + genericTransformationTest(intervalRewriting, Programs::toNormalProgram, "interval.1"); } @Test public void intervalTermToIntervalAtomExternalAtomTest() { - genericTransformationTest(intervalRewriting, NormalProgramImpl::fromInputProgram, "interval-external_atom"); + genericTransformationTest(intervalRewriting, Programs::toNormalProgram, "interval-external_atom"); } @Test public void intervalTermToIntervalAtomComparisonAtomTest() { - genericTransformationTest(intervalRewriting, NormalProgramImpl::fromInputProgram, "interval-comparison_atom"); + genericTransformationTest(intervalRewriting, Programs::toNormalProgram, "interval-comparison_atom"); } @SuppressWarnings("unused") diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java index 52b67afbb..c0bfdd991 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/SolverTests.java @@ -50,7 +50,6 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; @@ -83,7 +82,7 @@ public void testObjectProgram(RegressionTestConfig cfg) { final ASPCore2Program program = Programs.newASPCore2Program( Collections.emptyList(), Collections.singletonList(fact), - new InlineDirectivesImpl() + Programs.newInlineDirectives() ); assertEquals(singleton(new AnswerSetBuilder() diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 7bf9a8e8a..7bda46edc 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -70,7 +70,6 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.InlineDirectivesImpl; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; @@ -327,7 +326,7 @@ public void withExternalSubtype() throws Exception { Alpha system = new AlphaImpl(); - ASPCore2Program prog = Programs.newASPCore2Program(singletonList(rule), emptyList(), new InlineDirectivesImpl()); + ASPCore2Program prog = Programs.newASPCore2Program(singletonList(rule), emptyList(), Programs.newInlineDirectives()); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").instance("x").build())); From 1e4e1c1136287a9dbe751307d818a20876bdc048 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 16:15:14 +0200 Subject: [PATCH 45/96] test for directive reification --- .../kr/alpha/commons/programs/ReifierTest.java | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java index fdc215a05..b7425e737 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java @@ -12,6 +12,8 @@ import org.junit.jupiter.api.Test; +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; @@ -29,6 +31,8 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; @@ -344,7 +348,15 @@ public void reifyAtom() { @Test public void reifyDirectives() { - // TODO + InlineDirectives directives = Programs.newInlineDirectives(); + directives.addDirective(InlineDirectives.DIRECTIVE.enum_predicate_is, "bla"); + ASPCore2Program program = Programs.builder() + .addRule(Rules.newRule( + Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 0))), + Atoms.newBasicAtom(Predicates.getPredicate("b", 0)).toLiteral())) + .addInlineDirectives(directives) + .build(); + Set reified = new Reifier(newIdGenerator()).reifyProgram(program); + assertTrue(reified.contains(Atoms.newBasicAtom(Reifier.INLINE_DIRECTIVE, Terms.newConstant("enum_predicate_is"), Terms.newConstant("bla")))); } - } From 5c1cfbee719a483cc078b43ae4ffffd834b48a15 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 16:41:07 +0200 Subject: [PATCH 46/96] explicit contract for ID generation in Reifier --- .../kr/alpha/commons/programs/Reifier.java | 54 ++++++------ .../kr/alpha/commons/util/IdGenerator.java | 14 ++++ .../kr/alpha/commons/util/IntIdGenerator.java | 4 +- .../alpha/commons/programs/ReifierTest.java | 84 +++++++++---------- 4 files changed, 81 insertions(+), 75 deletions(-) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IdGenerator.java diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index cbe76be98..9bba32401 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -4,7 +4,6 @@ import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; -import java.util.function.Supplier; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; @@ -20,9 +19,9 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; @@ -32,6 +31,7 @@ import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; public class Reifier { @@ -179,11 +179,11 @@ public class Reifier { TERM_TYPES.put(Integer.class, "integer"); } - private final Supplier> idProvider; + private final IdGenerator> idProvider; private final Map> reifiedPredicates = new HashMap<>(); - public Reifier(Supplier> idProvider) { + public Reifier(IdGenerator> idProvider) { this.idProvider = idProvider; } @@ -191,7 +191,7 @@ public Set reifyProgram(ASPCore2Program program) { Set reified = new LinkedHashSet<>(); reified.addAll(reifyDirectives(program.getInlineDirectives())); for (Atom fact : program.getFacts()) { - ConstantTerm factId = idProvider.get(); + ConstantTerm factId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(FACT, factId)); reified.addAll(reifyAtom(factId, fact)); } @@ -221,12 +221,12 @@ Set reifyDirectives(InlineDirectives directives) { Set reifyRule(Rule rule) { Set reified = new LinkedHashSet<>(); - ConstantTerm ruleId = idProvider.get(); + ConstantTerm ruleId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(RULE, ruleId)); reified.addAll(reifyHead(ruleId, rule.getHead())); reified.add(Atoms.newBasicAtom(RULE_NUM_BODY_LITERALS, ruleId, Terms.newConstant(rule.getBody().size()))); for (Literal lit : rule.getBody()) { - ConstantTerm literalId = idProvider.get(); + ConstantTerm literalId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(RULE_BODY_LITERAL, ruleId, literalId)); reified.addAll(reifyLiteral(literalId, lit)); } @@ -235,7 +235,7 @@ Set reifyRule(Rule rule) { Set reifyHead(ConstantTerm ruleId, Head head) { Set reified = new LinkedHashSet<>(); - ConstantTerm headId = idProvider.get(); + ConstantTerm headId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(RULE_HEAD, ruleId, headId)); if (head instanceof NormalHead) { reified.addAll(reifyNormalHead(headId, (NormalHead) head)); @@ -250,7 +250,7 @@ Set reifyHead(ConstantTerm ruleId, Head head) { Set reifyNormalHead(ConstantTerm headId, NormalHead head) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_NORMAL)); - ConstantTerm atomId = idProvider.get(); + ConstantTerm atomId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(NORMAL_HEAD_ATOM, headId, atomId)); reified.addAll(reifyAtom(atomId, head.getAtom())); return reified; @@ -274,14 +274,14 @@ Set reifyChoiceHead(ConstantTerm headId, ChoiceHead head) { Set reifyChoiceElement(ConstantTerm headId, ChoiceElement element) { Set reified = new LinkedHashSet<>(); - ConstantTerm elementId = idProvider.get(); + ConstantTerm elementId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(CHOICE_HEAD_ELEMENT, headId, elementId)); - ConstantTerm atomId = idProvider.get(); + ConstantTerm atomId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_ATOM, elementId, atomId)); reified.addAll(reifyAtom(atomId, element.getChoiceAtom())); reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_NUM_CONDITION_LITERALS, elementId, Terms.newConstant(element.getConditionLiterals().size()))); for (Literal lit : element.getConditionLiterals()) { - ConstantTerm literalId = idProvider.get(); + ConstantTerm literalId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_CONDITION_LITERAL, elementId, literalId)); reified.addAll(reifyLiteral(literalId, lit)); } @@ -291,7 +291,7 @@ Set reifyChoiceElement(ConstantTerm headId, ChoiceElement element) Set reifyLiteral(ConstantTerm literalId, Literal lit) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(LITERAL_POLARITY, literalId, lit.isNegated() ? LITERAL_POLARITY_NEGATIVE : LITERAL_POLARITY_POSITIVE)); - ConstantTerm atomId = idProvider.get(); + ConstantTerm atomId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(LITERAL_ATOM, literalId, atomId)); reified.addAll(reifyAtom(atomId, lit.getAtom())); return reified; @@ -318,13 +318,13 @@ Set reifyBasicAtom(ConstantTerm atomId, BasicAtom atom) { if (reifiedPredicates.containsKey(atom.getPredicate())) { predicateId = reifiedPredicates.get(atom.getPredicate()); } else { - predicateId = idProvider.get(); + predicateId = idProvider.getNextId(); reifiedPredicates.put(atom.getPredicate(), predicateId); } reified.add(Atoms.newBasicAtom(BASIC_ATOM_PREDICATE, atomId, predicateId)); reified.add(Atoms.newBasicAtom(BASIC_ATOM_NUM_TERMS, atomId, Terms.newConstant(atom.getTerms().size()))); for (int i = 0; i < atom.getTerms().size(); i++) { - ConstantTerm termId = idProvider.get(); + ConstantTerm termId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(BASIC_ATOM_TERM, atomId, Terms.newConstant(i), termId)); reified.addAll(reifyTerm(termId, atom.getTerms().get(i))); } @@ -334,8 +334,8 @@ Set reifyBasicAtom(ConstantTerm atomId, BasicAtom atom) { Set reifyComparisonAtom(ConstantTerm atomId, ComparisonAtom atom) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_COMPARISON)); - ConstantTerm leftTermId = idProvider.get(); - ConstantTerm rightTermId = idProvider.get(); + ConstantTerm leftTermId = idProvider.getNextId(); + ConstantTerm rightTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_LEFT, atomId, leftTermId)); reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_RIGHT, atomId, rightTermId)); if (!CMP_OPS.containsKey(atom.getOperator())) { @@ -353,13 +353,13 @@ Set reifyExternalAtom(ConstantTerm atomId, ExternalAtom atom) { reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_INPUT_TERMS, atomId, Terms.newConstant(atom.getInput().size()))); for (int i = 0; i < atom.getInput().size(); i++) { - ConstantTerm inTermId = idProvider.get(); + ConstantTerm inTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_INPUT_TERM, atomId, Terms.newConstant(i), inTermId)); reified.addAll(reifyTerm(inTermId, atom.getInput().get(i))); } reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_OUTPUT_TERMS, atomId, Terms.newConstant(atom.getOutput().size()))); for (int i = 0; i < atom.getOutput().size(); i++) { - ConstantTerm outTermId = idProvider.get(); + ConstantTerm outTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_OUTPUT_TERM, atomId, Terms.newConstant(i), outTermId)); reified.addAll(reifyTerm(outTermId, atom.getOutput().get(i))); } @@ -372,17 +372,17 @@ Set reifyAggregateAtom(ConstantTerm atomId, AggregateAtom atom) { reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_FUNCTION, atomId, AGG_FUNCS.get(atom.getAggregateFunction()))); if (atom.getLowerBoundOperator() != null) { reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_OPERATOR, atomId, CMP_OPS.get(atom.getLowerBoundOperator()))); - ConstantTerm leftTermId = idProvider.get(); + ConstantTerm leftTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_TERM, atomId, leftTermId)); } if (atom.getUpperBoundOperator() != null) { reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_OPERATOR, atomId, CMP_OPS.get(atom.getUpperBoundOperator()))); - ConstantTerm rightTermId = idProvider.get(); + ConstantTerm rightTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_TERM, atomId, rightTermId)); } reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_NUM_AGGREGATE_ELEMENTS, atomId, Terms.newConstant(atom.getAggregateElements().size()))); for (AggregateElement element : atom.getAggregateElements()) { - ConstantTerm elementId = idProvider.get(); + ConstantTerm elementId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_ELEMENT, atomId, elementId)); reified.addAll(reifyAggregateElement(elementId, element)); } @@ -393,13 +393,13 @@ Set reifyAggregateElement(ConstantTerm elementId, AggregateElement Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_TERMS, elementId, Terms.newConstant(element.getElementTerms().size()))); for (int i = 0; i < element.getElementTerms().size(); i++) { - ConstantTerm termId = idProvider.get(); + ConstantTerm termId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_TERM, elementId, Terms.newConstant(i), termId)); reified.addAll(reifyTerm(termId, element.getElementTerms().get(i))); } reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_LITERALS, elementId, Terms.newConstant(element.getElementLiterals().size()))); for (Literal lit : element.getElementLiterals()) { - ConstantTerm literalId = idProvider.get(); + ConstantTerm literalId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_LITERAL, elementId, literalId)); reified.addAll(reifyLiteral(literalId, lit)); } @@ -444,10 +444,10 @@ Set reifyVariableTerm(ConstantTerm termId, VariableTerm term) { Set reifyArithmeticTerm(ConstantTerm termId, ArithmeticTerm term) { Set reified = new LinkedHashSet<>(); reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_ARITHMETIC)); - ConstantTerm leftTermId = idProvider.get(); + ConstantTerm leftTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_LEFT, termId, leftTermId)); reified.addAll(reifyTerm(leftTermId, term.getLeftOperand())); - ConstantTerm rightTermId = idProvider.get(); + ConstantTerm rightTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_RIGHT, termId, rightTermId)); reified.addAll(reifyTerm(rightTermId, term.getRightOperand())); reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_OPERATOR, termId, Terms.newConstant(term.getOperator().toString()))); @@ -460,7 +460,7 @@ Set reifyFunctionTerm(ConstantTerm termId, FunctionTerm term) { reified.add(Atoms.newBasicAtom(FUNCTION_TERM_SYMBOL, termId, Terms.newConstant(term.getSymbol()))); reified.add(Atoms.newBasicAtom(FUNCTION_TERM_NUM_ARGUMENTS, termId, Terms.newConstant(term.getTerms().size()))); for (int i = 0; i < term.getTerms().size(); i++) { - ConstantTerm argTermId = idProvider.get(); + ConstantTerm argTermId = idProvider.getNextId(); reified.add(Atoms.newBasicAtom(FUNCTION_TERM_ARGUMENT, termId, Terms.newConstant(i), argTermId)); reified.addAll(reifyTerm(argTermId, term.getTerms().get(i))); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IdGenerator.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IdGenerator.java new file mode 100644 index 000000000..526dee3d9 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IdGenerator.java @@ -0,0 +1,14 @@ +package at.ac.tuwien.kr.alpha.commons.util; + +/** + * A generator of (per instance) unique values that can be used for uniquely identifying internal variables, etc. + */ +@FunctionalInterface +public interface IdGenerator { + + /** + * Retrieves the next identifier value from the internal sequence of this id generator. + */ + T getNextId(); + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IntIdGenerator.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IntIdGenerator.java index df044d1b7..f807609d3 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IntIdGenerator.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/IntIdGenerator.java @@ -6,7 +6,7 @@ * Generates unique, sequential integers starting at 0, i.e., it maintains a counter that is incremented for each getNextId(). * Copyright (c) 2016, the Alpha Team. */ -public class IntIdGenerator { +public class IntIdGenerator implements IdGenerator { private int highestId; public IntIdGenerator() { @@ -17,7 +17,7 @@ public IntIdGenerator(int initial) { this.highestId = initial; } - public int getNextId() { + public Integer getNextId() { if (highestId == Integer.MAX_VALUE) { throw oops("Ran out of IDs (integer overflow)"); } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java index b7425e737..d56a1aa3c 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java @@ -7,7 +7,6 @@ import java.util.Collections; import java.util.List; import java.util.Set; -import java.util.function.Supplier; import java.util.stream.Collectors; import org.junit.jupiter.api.Test; @@ -34,28 +33,21 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; public class ReifierTest { - private Supplier> newIdGenerator() { - return new Supplier>() { - - IntIdGenerator idGen = new IntIdGenerator(0); - - @Override - public ConstantTerm get() { - return Terms.newConstant(idGen.getNextId()); - } - - }; + private IdGenerator> newIdGenerator() { + final IntIdGenerator idGen = new IntIdGenerator(0); + return () -> Terms.newConstant(idGen.getNextId()); } @Test public void reifySymbolicConstant() { ConstantTerm constant = Terms.newSymbolicConstant("someConstant"); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("symbol")))); @@ -65,8 +57,8 @@ public void reifySymbolicConstant() { @Test public void reifyStringConstant() { ConstantTerm constant = Terms.newConstant("someString"); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); @@ -76,8 +68,8 @@ public void reifyStringConstant() { @Test public void reifyStringWithQuotes() { ConstantTerm constant = Terms.newConstant("someStringWith\"Quotes\""); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); @@ -88,8 +80,8 @@ public void reifyStringWithQuotes() { @Test public void reifyIntegerConstant() { ConstantTerm constant = Terms.newConstant(666); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("integer")))); @@ -99,8 +91,8 @@ public void reifyIntegerConstant() { @Test public void reifyVariable() { VariableTerm var = Terms.newVariable("SOME_VAR"); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyVariableTerm(reifiedId, var); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("variable")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("variableTerm_symbol", 2), reifiedId, Terms.newConstant("SOME_VAR")))); @@ -109,8 +101,8 @@ public void reifyVariable() { @Test public void reifyArithmeticTerm() { Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyArithmeticTerm(reifiedId, (ArithmeticTerm) arithmeticTerm); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("arithmetic")))); assertTrue(reified.contains( @@ -128,8 +120,8 @@ public void reifyArithmeticTerm() { @Test public void reifyFunctionTerm() { FunctionTerm funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyFunctionTerm(reifiedId, funcTerm); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("function")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_symbol", 2), reifiedId, Terms.newConstant("f")))); @@ -146,22 +138,22 @@ public void reifyTerm() { Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); Term funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); - Supplier> idGen = newIdGenerator(); + IdGenerator> idGen = newIdGenerator(); Reifier reificationHelper = new Reifier(idGen); - ConstantTerm constId = idGen.get(); + ConstantTerm constId = idGen.getNextId(); Set reifiedConst = reificationHelper.reifyTerm(constId, constTerm); assertTrue(reifiedConst.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), constId, Terms.newSymbolicConstant("constant")))); - ConstantTerm varId = idGen.get(); + ConstantTerm varId = idGen.getNextId(); Set reifiedVar = reificationHelper.reifyTerm(varId, varTerm); assertTrue(reifiedVar.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), varId, Terms.newSymbolicConstant("variable")))); - ConstantTerm calcId = idGen.get(); + ConstantTerm calcId = idGen.getNextId(); Set reifiedCalc = reificationHelper.reifyTerm(calcId, arithmeticTerm); assertTrue(reifiedCalc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), calcId, Terms.newSymbolicConstant("arithmetic")))); - ConstantTerm funcId = idGen.get(); + ConstantTerm funcId = idGen.getNextId(); Set reifiedFunc = reificationHelper.reifyTerm(funcId, funcTerm); assertTrue(reifiedFunc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), funcId, Terms.newSymbolicConstant("function")))); } @@ -169,8 +161,8 @@ public void reifyTerm() { @Test public void reifyBasicAtom() { BasicAtom atom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyBasicAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("basic")))); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("basicAtom_numTerms", 2), reifiedId, Terms.newConstant(2)))); @@ -185,8 +177,8 @@ public void reifyBasicAtom() { @Test public void reifyComparisonAtom() { ComparisonAtom atom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyComparisonAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("comparison")))); assertEquals(1, @@ -211,8 +203,8 @@ public void reifyAggregateElement() { List elementLiterals = new ArrayList<>(); elementLiterals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom", 1), Terms.newVariable("X")).toLiteral()); AggregateElement element = Atoms.newAggregateElement(elementTerms, elementLiterals); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyAggregateElement(reifiedId, element); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numTerms", 2), reifiedId, Terms.newConstant(1)))); assertEquals(1, @@ -249,8 +241,8 @@ public void reifyAggregateAtom() { elements.add(element2); AggregateAtom atom = Atoms.newAggregateAtom(ComparisonOperators.EQ, Terms.newVariable("X"), AggregateFunctionSymbol.COUNT, elements); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyAggregateAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("aggregate")))); @@ -273,8 +265,8 @@ public void reifyExternalAtom() { extOutput.add(Terms.newVariable("O")); ExternalAtom atom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); - Supplier> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.get(); + IdGenerator> idGen = newIdGenerator(); + ConstantTerm reifiedId = idGen.getNextId(); Set reified = new Reifier(idGen).reifyExternalAtom(reifiedId, atom); assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("external")))); @@ -327,21 +319,21 @@ public void reifyAtom() { extOutput.add(Terms.newVariable("O")); ExternalAtom extAtom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); - Supplier> idGen = newIdGenerator(); + IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedBasicAtomId = idGen.get(); + ConstantTerm reifiedBasicAtomId = idGen.getNextId(); Set reifiedBasicAtom = new Reifier(idGen).reifyAtom(reifiedBasicAtomId, basicAtom); assertTrue(reifiedBasicAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedBasicAtomId, Terms.newSymbolicConstant("basic")))); - ConstantTerm reifiedCmpAtomId = idGen.get(); + ConstantTerm reifiedCmpAtomId = idGen.getNextId(); Set reifiedCmpAtom = new Reifier(idGen).reifyAtom(reifiedCmpAtomId, cmpAtom); assertTrue(reifiedCmpAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedCmpAtomId, Terms.newSymbolicConstant("comparison")))); - ConstantTerm reifiedAggAtomId = idGen.get(); + ConstantTerm reifiedAggAtomId = idGen.getNextId(); Set reifiedAggAtom = new Reifier(idGen).reifyAtom(reifiedAggAtomId, aggAtom); assertTrue(reifiedAggAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedAggAtomId, Terms.newSymbolicConstant("aggregate")))); - ConstantTerm reifiedExtAtomId = idGen.get(); + ConstantTerm reifiedExtAtomId = idGen.getNextId(); Set reifiedExtAtom = new Reifier(idGen).reifyAtom(reifiedExtAtomId, extAtom); assertTrue(reifiedExtAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedExtAtomId, Terms.newSymbolicConstant("external")))); } From 5ec6adbb7b2dece762b3476fee3f4ab0b34ada04 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 17:17:31 +0200 Subject: [PATCH 47/96] reify interval terms --- .../kr/alpha/commons/programs/Reifier.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index 9bba32401..fff65e587 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -25,6 +25,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; @@ -121,6 +122,10 @@ public class Reifier { static final Predicate FUNCTION_TERM_NUM_ARGUMENTS = Predicates.getPredicate("functionTerm_numArguments", 2); static final Predicate FUNCTION_TERM_ARGUMENT = Predicates.getPredicate("functionTerm_argumentTerm", 3); + // Predicates describing interval terms + static final Predicate INTERVAL_TERM_LOWER = Predicates.getPredicate("intervalTerm_lower", 2); + static final Predicate INTERVAL_TERM_UPPER = Predicates.getPredicate("intervalTerm_Upper", 2); + // Predicates describing InlineDirectives static final Predicate INLINE_DIRECTIVE = Predicates.getPredicate("inlineDirective", 2); @@ -157,6 +162,7 @@ public class Reifier { static final ConstantTerm TERM_TYPE_VARIABLE = Terms.newSymbolicConstant("variable"); static final ConstantTerm TERM_TYPE_ARITHMETIC = Terms.newSymbolicConstant("arithmetic"); static final ConstantTerm TERM_TYPE_FUNCTION = Terms.newSymbolicConstant("function"); + static final ConstantTerm TERM_TYPE_INTERVAL = Terms.newSymbolicConstant("interval"); private static final Map> CMP_OPS = new HashMap<>(); private static final Map> AGG_FUNCS = new HashMap<>(); @@ -415,6 +421,8 @@ Set reifyTerm(ConstantTerm termId, Term term) { return reifyArithmeticTerm(termId, (ArithmeticTerm) term); } else if (term instanceof FunctionTerm) { return reifyFunctionTerm(termId, (FunctionTerm) term); + } else if (term instanceof IntervalTerm) { + return reifyIntervalTerm(termId, (IntervalTerm) term); } else { throw new IllegalArgumentException("Cannot reify term of type " + term.getClass().getSimpleName()); } @@ -467,4 +475,16 @@ Set reifyFunctionTerm(ConstantTerm termId, FunctionTerm term) { return reified; } + Set reifyIntervalTerm(ConstantTerm termId, IntervalTerm term) { + Set reified = new LinkedHashSet<>(); + reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_INTERVAL)); + ConstantTerm lowerTermId = idProvider.getNextId(); + reified.add(Atoms.newBasicAtom(INTERVAL_TERM_LOWER, termId, lowerTermId)); + reified.addAll(reifyTerm(lowerTermId, term.getLowerBound())); + ConstantTerm upperTermId = idProvider.getNextId(); + reified.add(Atoms.newBasicAtom(INTERVAL_TERM_UPPER, termId, upperTermId)); + reified.addAll(reifyTerm(upperTermId, term.getUpperBound())); + return reified; + } + } From 09fe84e5d340909719c490f4d30074884893b509 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 12 Oct 2022 17:23:40 +0200 Subject: [PATCH 48/96] code cleanup - improve exceptions --- .../at/ac/tuwien/kr/alpha/commons/programs/Reifier.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index fff65e587..5deefa4cd 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -33,6 +33,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; +import at.ac.tuwien.kr.alpha.commons.util.Util; public class Reifier { @@ -248,7 +249,7 @@ Set reifyHead(ConstantTerm ruleId, Head head) { } else if (head instanceof ChoiceHead) { reified.addAll(reifyChoiceHead(headId, (ChoiceHead) head)); } else { - throw new IllegalArgumentException("Head type " + head.getClass().getSimpleName() + " cannot be reified!"); + throw Util.oops("Head type " + head.getClass().getSimpleName() + " cannot be reified!"); } return reified; } @@ -313,7 +314,7 @@ Set reifyAtom(ConstantTerm atomId, Atom atom) { } else if (atom instanceof AggregateAtom) { return reifyAggregateAtom(atomId, (AggregateAtom) atom); } else { - throw new IllegalArgumentException("Atom type " + atom.getClass().getSimpleName() + " cannot be reified!"); + throw Util.oops("Atom type " + atom.getClass().getSimpleName() + " cannot be reified!"); } } @@ -345,7 +346,7 @@ Set reifyComparisonAtom(ConstantTerm atomId, ComparisonAtom atom) reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_LEFT, atomId, leftTermId)); reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_RIGHT, atomId, rightTermId)); if (!CMP_OPS.containsKey(atom.getOperator())) { - throw new IllegalArgumentException("Cannot reifiy comparison operator " + atom.getOperator()); + throw Util.oops("Cannot reifiy comparison operator " + atom.getOperator()); } reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_OPERATOR, atomId, CMP_OPS.get(atom.getOperator()))); reified.addAll(reifyTerm(leftTermId, atom.getTerms().get(0))); @@ -424,7 +425,7 @@ Set reifyTerm(ConstantTerm termId, Term term) { } else if (term instanceof IntervalTerm) { return reifyIntervalTerm(termId, (IntervalTerm) term); } else { - throw new IllegalArgumentException("Cannot reify term of type " + term.getClass().getSimpleName()); + throw Util.oops("Cannot reify term of type " + term.getClass().getSimpleName()); } } From a910fb98b6e67cdd9354f45029ce29370f9d66c9 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sat, 22 Oct 2022 12:21:42 +0200 Subject: [PATCH 49/96] WIP: reduce useless object creation in Reifier --- .../kr/alpha/commons/programs/Reifier.java | 374 +++++++++--------- 1 file changed, 188 insertions(+), 186 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java index 5deefa4cd..7e8f63954 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java @@ -4,6 +4,7 @@ import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; +import java.util.function.Supplier; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; @@ -186,306 +187,307 @@ public class Reifier { TERM_TYPES.put(Integer.class, "integer"); } - private final IdGenerator> idProvider; + private final Supplier>> idGeneratorProvider; - private final Map> reifiedPredicates = new HashMap<>(); - - public Reifier(IdGenerator> idProvider) { - this.idProvider = idProvider; + public Reifier(Supplier>> idGeneratorProvider) { + this.idGeneratorProvider = idGeneratorProvider; } public Set reifyProgram(ASPCore2Program program) { - Set reified = new LinkedHashSet<>(); - reified.addAll(reifyDirectives(program.getInlineDirectives())); + ReificationContext ctx = new ReificationContext(idGeneratorProvider.get()); + reifyDirectives(ctx, program.getInlineDirectives()); for (Atom fact : program.getFacts()) { - ConstantTerm factId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(FACT, factId)); - reified.addAll(reifyAtom(factId, fact)); + ConstantTerm factId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(FACT, factId)); + reifyAtom(ctx, factId, fact); } for (Rule rule : program.getRules()) { if (rule.isConstraint()) { continue; } - reified.addAll(reifyRule(rule)); + reifyRule(ctx, rule); } + // TODO do this in context! for (Map.Entry> entry : reifiedPredicates.entrySet()) { - reified.add(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), + ctx.addAtom(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), Terms.newConstant(entry.getKey().getArity()))); } - return reified; + return ctx.reifiedProgram(); } /** * Generates atoms of form inlineDirective("", ""). */ - Set reifyDirectives(InlineDirectives directives) { - Set reified = new LinkedHashSet<>(); + void reifyDirectives(ReificationContext ctx, InlineDirectives directives) { for (Map.Entry entry : directives.getDirectives().entrySet()) { - reified.add(Atoms.newBasicAtom(INLINE_DIRECTIVE, Terms.newConstant(entry.getKey().name()), Terms.newConstant(entry.getValue()))); + ctx.addAtom(Atoms.newBasicAtom(INLINE_DIRECTIVE, Terms.newConstant(entry.getKey().name()), Terms.newConstant(entry.getValue()))); } - return reified; } - Set reifyRule(Rule rule) { - Set reified = new LinkedHashSet<>(); - ConstantTerm ruleId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(RULE, ruleId)); - reified.addAll(reifyHead(ruleId, rule.getHead())); - reified.add(Atoms.newBasicAtom(RULE_NUM_BODY_LITERALS, ruleId, Terms.newConstant(rule.getBody().size()))); + void reifyRule(ReificationContext ctx, Rule rule) { + ConstantTerm ruleId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(RULE, ruleId)); + reifyHead(ctx, ruleId, rule.getHead()); + ctx.addAtom(Atoms.newBasicAtom(RULE_NUM_BODY_LITERALS, ruleId, Terms.newConstant(rule.getBody().size()))); for (Literal lit : rule.getBody()) { - ConstantTerm literalId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(RULE_BODY_LITERAL, ruleId, literalId)); - reified.addAll(reifyLiteral(literalId, lit)); + ConstantTerm literalId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(RULE_BODY_LITERAL, ruleId, literalId)); + reifyLiteral(ctx, literalId, lit); } - return reified; } - Set reifyHead(ConstantTerm ruleId, Head head) { - Set reified = new LinkedHashSet<>(); - ConstantTerm headId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(RULE_HEAD, ruleId, headId)); + void reifyHead(ReificationContext ctx, ConstantTerm ruleId, Head head) { + ConstantTerm headId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(RULE_HEAD, ruleId, headId)); if (head instanceof NormalHead) { - reified.addAll(reifyNormalHead(headId, (NormalHead) head)); + reifyNormalHead(ctx, headId, (NormalHead) head); } else if (head instanceof ChoiceHead) { - reified.addAll(reifyChoiceHead(headId, (ChoiceHead) head)); + reifyChoiceHead(ctx, headId, (ChoiceHead) head); } else { throw Util.oops("Head type " + head.getClass().getSimpleName() + " cannot be reified!"); } - return reified; } - Set reifyNormalHead(ConstantTerm headId, NormalHead head) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_NORMAL)); - ConstantTerm atomId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(NORMAL_HEAD_ATOM, headId, atomId)); - reified.addAll(reifyAtom(atomId, head.getAtom())); - return reified; + void reifyNormalHead(ReificationContext ctx, ConstantTerm headId, NormalHead head) { + ctx.addAtom(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_NORMAL)); + ConstantTerm atomId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(NORMAL_HEAD_ATOM, headId, atomId)); + reifyAtom(ctx, atomId, head.getAtom()); } - Set reifyChoiceHead(ConstantTerm headId, ChoiceHead head) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_CHOICE)); + void reifyChoiceHead(ReificationContext ctx, ConstantTerm headId, ChoiceHead head) { + ctx.addAtom(Atoms.newBasicAtom(HEAD_TYPE, headId, HEAD_TYPE_CHOICE)); if (head.getLowerBound() != null) { - reified.add(Atoms.newBasicAtom(CHOICE_HEAD_LOWER_BOUND, headId, head.getLowerBound())); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_HEAD_LOWER_BOUND, headId, head.getLowerBound())); } if (head.getUpperBound() != null) { - reified.add(Atoms.newBasicAtom(CHOICE_HEAD_UPPER_BOUND, headId, head.getUpperBound())); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_HEAD_UPPER_BOUND, headId, head.getUpperBound())); } - reified.add(Atoms.newBasicAtom(CHOICE_HEAD_NUM_ELEMENTS, headId, Terms.newConstant(head.getChoiceElements().size()))); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_HEAD_NUM_ELEMENTS, headId, Terms.newConstant(head.getChoiceElements().size()))); for (ChoiceElement element : head.getChoiceElements()) { - reified.addAll(reifyChoiceElement(headId, element)); + reifyChoiceElement(ctx, headId, element); } - return reified; } - Set reifyChoiceElement(ConstantTerm headId, ChoiceElement element) { - Set reified = new LinkedHashSet<>(); - ConstantTerm elementId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(CHOICE_HEAD_ELEMENT, headId, elementId)); - ConstantTerm atomId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_ATOM, elementId, atomId)); - reified.addAll(reifyAtom(atomId, element.getChoiceAtom())); - reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_NUM_CONDITION_LITERALS, elementId, Terms.newConstant(element.getConditionLiterals().size()))); + void reifyChoiceElement(ReificationContext ctx, ConstantTerm headId, ChoiceElement element) { + ConstantTerm elementId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_HEAD_ELEMENT, headId, elementId)); + ConstantTerm atomId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_ELEMENT_ATOM, elementId, atomId)); + reifyAtom(ctx, atomId, element.getChoiceAtom()); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_ELEMENT_NUM_CONDITION_LITERALS, elementId, Terms.newConstant(element.getConditionLiterals().size()))); for (Literal lit : element.getConditionLiterals()) { - ConstantTerm literalId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(CHOICE_ELEMENT_CONDITION_LITERAL, elementId, literalId)); - reified.addAll(reifyLiteral(literalId, lit)); + ConstantTerm literalId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(CHOICE_ELEMENT_CONDITION_LITERAL, elementId, literalId)); + reifyLiteral(ctx, literalId, lit); } - return reified; } - Set reifyLiteral(ConstantTerm literalId, Literal lit) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(LITERAL_POLARITY, literalId, lit.isNegated() ? LITERAL_POLARITY_NEGATIVE : LITERAL_POLARITY_POSITIVE)); - ConstantTerm atomId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(LITERAL_ATOM, literalId, atomId)); - reified.addAll(reifyAtom(atomId, lit.getAtom())); - return reified; + void reifyLiteral(ReificationContext ctx, ConstantTerm literalId, Literal lit) { + ctx.addAtom(Atoms.newBasicAtom(LITERAL_POLARITY, literalId, lit.isNegated() ? LITERAL_POLARITY_NEGATIVE : LITERAL_POLARITY_POSITIVE)); + ConstantTerm atomId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(LITERAL_ATOM, literalId, atomId)); + reifyAtom(ctx, atomId, lit.getAtom()); } - Set reifyAtom(ConstantTerm atomId, Atom atom) { + void reifyAtom(ReificationContext ctx, ConstantTerm atomId, Atom atom) { if (atom instanceof BasicAtom) { - return reifyBasicAtom(atomId, (BasicAtom) atom); + reifyBasicAtom(ctx, atomId, (BasicAtom) atom); } else if (atom instanceof ComparisonAtom) { - return reifyComparisonAtom(atomId, (ComparisonAtom) atom); + reifyComparisonAtom(ctx, atomId, (ComparisonAtom) atom); } else if (atom instanceof ExternalAtom) { - return reifyExternalAtom(atomId, (ExternalAtom) atom); + reifyExternalAtom(ctx, atomId, (ExternalAtom) atom); } else if (atom instanceof AggregateAtom) { - return reifyAggregateAtom(atomId, (AggregateAtom) atom); + reifyAggregateAtom(ctx, atomId, (AggregateAtom) atom); } else { throw Util.oops("Atom type " + atom.getClass().getSimpleName() + " cannot be reified!"); } } - Set reifyBasicAtom(ConstantTerm atomId, BasicAtom atom) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_BASIC)); - ConstantTerm predicateId; - if (reifiedPredicates.containsKey(atom.getPredicate())) { - predicateId = reifiedPredicates.get(atom.getPredicate()); - } else { - predicateId = idProvider.getNextId(); - reifiedPredicates.put(atom.getPredicate(), predicateId); - } - reified.add(Atoms.newBasicAtom(BASIC_ATOM_PREDICATE, atomId, predicateId)); - reified.add(Atoms.newBasicAtom(BASIC_ATOM_NUM_TERMS, atomId, Terms.newConstant(atom.getTerms().size()))); + void reifyBasicAtom(ReificationContext ctx, ConstantTerm atomId, BasicAtom atom) { + ctx.addAtom(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_BASIC)); + ConstantTerm predicateId = ctx.computePredicateId(atom.getPredicate()); + ctx.addAtom(Atoms.newBasicAtom(BASIC_ATOM_PREDICATE, atomId, predicateId)); + ctx.addAtom(Atoms.newBasicAtom(BASIC_ATOM_NUM_TERMS, atomId, Terms.newConstant(atom.getTerms().size()))); for (int i = 0; i < atom.getTerms().size(); i++) { - ConstantTerm termId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(BASIC_ATOM_TERM, atomId, Terms.newConstant(i), termId)); - reified.addAll(reifyTerm(termId, atom.getTerms().get(i))); + ConstantTerm termId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(BASIC_ATOM_TERM, atomId, Terms.newConstant(i), termId)); + reifyTerm(ctx, termId, atom.getTerms().get(i)); } - return reified; } - Set reifyComparisonAtom(ConstantTerm atomId, ComparisonAtom atom) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_COMPARISON)); - ConstantTerm leftTermId = idProvider.getNextId(); - ConstantTerm rightTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_LEFT, atomId, leftTermId)); - reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_RIGHT, atomId, rightTermId)); + void reifyComparisonAtom(ReificationContext ctx, ConstantTerm atomId, ComparisonAtom atom) { + ctx.addAtom(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_COMPARISON)); + ConstantTerm leftTermId = ctx.getNextId(); + ConstantTerm rightTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(COMPARISON_ATOM_LEFT, atomId, leftTermId)); + ctx.addAtom(Atoms.newBasicAtom(COMPARISON_ATOM_RIGHT, atomId, rightTermId)); if (!CMP_OPS.containsKey(atom.getOperator())) { throw Util.oops("Cannot reifiy comparison operator " + atom.getOperator()); } - reified.add(Atoms.newBasicAtom(COMPARISON_ATOM_OPERATOR, atomId, CMP_OPS.get(atom.getOperator()))); - reified.addAll(reifyTerm(leftTermId, atom.getTerms().get(0))); - reified.addAll(reifyTerm(rightTermId, atom.getTerms().get(1))); - return reified; + ctx.addAtom(Atoms.newBasicAtom(COMPARISON_ATOM_OPERATOR, atomId, CMP_OPS.get(atom.getOperator()))); + reifyTerm(ctx, leftTermId, atom.getTerms().get(0)); + reifyTerm(ctx, rightTermId, atom.getTerms().get(1)); } - Set reifyExternalAtom(ConstantTerm atomId, ExternalAtom atom) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_EXTERNAL)); - reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); - reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_INPUT_TERMS, atomId, Terms.newConstant(atom.getInput().size()))); + void reifyExternalAtom(ReificationContext ctx, ConstantTerm atomId, ExternalAtom atom) { + ctx.addAtom(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_EXTERNAL)); + ctx.addAtom(Atoms.newBasicAtom(EXTERNAL_ATOM_NAME, atomId, Terms.newConstant(atom.getPredicate().getName()))); + ctx.addAtom(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_INPUT_TERMS, atomId, Terms.newConstant(atom.getInput().size()))); for (int i = 0; i < atom.getInput().size(); i++) { - ConstantTerm inTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_INPUT_TERM, atomId, Terms.newConstant(i), inTermId)); - reified.addAll(reifyTerm(inTermId, atom.getInput().get(i))); + ConstantTerm inTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(EXTERNAL_ATOM_INPUT_TERM, atomId, Terms.newConstant(i), inTermId)); + reifyTerm(ctx, inTermId, atom.getInput().get(i)); } - reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_OUTPUT_TERMS, atomId, Terms.newConstant(atom.getOutput().size()))); + ctx.addAtom(Atoms.newBasicAtom(EXTERNAL_ATOM_NUM_OUTPUT_TERMS, atomId, Terms.newConstant(atom.getOutput().size()))); for (int i = 0; i < atom.getOutput().size(); i++) { - ConstantTerm outTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(EXTERNAL_ATOM_OUTPUT_TERM, atomId, Terms.newConstant(i), outTermId)); - reified.addAll(reifyTerm(outTermId, atom.getOutput().get(i))); + ConstantTerm outTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(EXTERNAL_ATOM_OUTPUT_TERM, atomId, Terms.newConstant(i), outTermId)); + reifyTerm(ctx, outTermId, atom.getOutput().get(i)); } - return reified; } - Set reifyAggregateAtom(ConstantTerm atomId, AggregateAtom atom) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_AGGREGATE)); - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_FUNCTION, atomId, AGG_FUNCS.get(atom.getAggregateFunction()))); + void reifyAggregateAtom(ReificationContext ctx, ConstantTerm atomId, AggregateAtom atom) { + ctx.addAtom(Atoms.newBasicAtom(ATOM_TYPE, atomId, ATOM_TYPE_AGGREGATE)); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_FUNCTION, atomId, AGG_FUNCS.get(atom.getAggregateFunction()))); if (atom.getLowerBoundOperator() != null) { - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_OPERATOR, atomId, CMP_OPS.get(atom.getLowerBoundOperator()))); - ConstantTerm leftTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_TERM, atomId, leftTermId)); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_OPERATOR, atomId, CMP_OPS.get(atom.getLowerBoundOperator()))); + ConstantTerm leftTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_LEFT_TERM, atomId, leftTermId)); } if (atom.getUpperBoundOperator() != null) { - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_OPERATOR, atomId, CMP_OPS.get(atom.getUpperBoundOperator()))); - ConstantTerm rightTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_TERM, atomId, rightTermId)); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_OPERATOR, atomId, CMP_OPS.get(atom.getUpperBoundOperator()))); + ConstantTerm rightTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_RIGHT_TERM, atomId, rightTermId)); } - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_NUM_AGGREGATE_ELEMENTS, atomId, Terms.newConstant(atom.getAggregateElements().size()))); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_NUM_AGGREGATE_ELEMENTS, atomId, Terms.newConstant(atom.getAggregateElements().size()))); for (AggregateElement element : atom.getAggregateElements()) { - ConstantTerm elementId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_ELEMENT, atomId, elementId)); - reified.addAll(reifyAggregateElement(elementId, element)); + ConstantTerm elementId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ATOM_AGGREGATE_ELEMENT, atomId, elementId)); + reifyAggregateElement(ctx, elementId, element); } - return reified; } - Set reifyAggregateElement(ConstantTerm elementId, AggregateElement element) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_TERMS, elementId, Terms.newConstant(element.getElementTerms().size()))); + void reifyAggregateElement(ReificationContext ctx, ConstantTerm elementId, AggregateElement element) { + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_TERMS, elementId, Terms.newConstant(element.getElementTerms().size()))); for (int i = 0; i < element.getElementTerms().size(); i++) { - ConstantTerm termId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_TERM, elementId, Terms.newConstant(i), termId)); - reified.addAll(reifyTerm(termId, element.getElementTerms().get(i))); + ConstantTerm termId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ELEMENT_TERM, elementId, Terms.newConstant(i), termId)); + reifyTerm(ctx, termId, element.getElementTerms().get(i)); } - reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_LITERALS, elementId, Terms.newConstant(element.getElementLiterals().size()))); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ELEMENT_NUM_LITERALS, elementId, Terms.newConstant(element.getElementLiterals().size()))); for (Literal lit : element.getElementLiterals()) { - ConstantTerm literalId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(AGGREGATE_ELEMENT_LITERAL, elementId, literalId)); - reified.addAll(reifyLiteral(literalId, lit)); + ConstantTerm literalId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(AGGREGATE_ELEMENT_LITERAL, elementId, literalId)); + reifyLiteral(ctx, literalId, lit); } - return reified; } - Set reifyTerm(ConstantTerm termId, Term term) { + void reifyTerm(ReificationContext ctx, ConstantTerm termId, Term term) { if (term instanceof ConstantTerm) { - return reifyConstantTerm(termId, (ConstantTerm) term); + reifyConstantTerm(ctx, termId, (ConstantTerm) term); } else if (term instanceof VariableTerm) { - return reifyVariableTerm(termId, (VariableTerm) term); + reifyVariableTerm(ctx, termId, (VariableTerm) term); } else if (term instanceof ArithmeticTerm) { - return reifyArithmeticTerm(termId, (ArithmeticTerm) term); + reifyArithmeticTerm(ctx, termId, (ArithmeticTerm) term); } else if (term instanceof FunctionTerm) { - return reifyFunctionTerm(termId, (FunctionTerm) term); + reifyFunctionTerm(ctx, termId, (FunctionTerm) term); } else if (term instanceof IntervalTerm) { - return reifyIntervalTerm(termId, (IntervalTerm) term); + reifyIntervalTerm(ctx, termId, (IntervalTerm) term); } else { throw Util.oops("Cannot reify term of type " + term.getClass().getSimpleName()); } } - Set reifyConstantTerm(ConstantTerm termId, ConstantTerm term) { - Set reified = new LinkedHashSet<>(); + void reifyConstantTerm(ReificationContext ctx, ConstantTerm termId, ConstantTerm term) { String termType; if (term.isSymbolic()) { termType = "symbol"; } else { termType = TERM_TYPES.getOrDefault(term.getObject().getClass(), "object(" + term.getObject().getClass().getName() + ")"); } - reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); - reified.add(Atoms.newBasicAtom(CONSTANT_TERM_TYPE, termId, Terms.newConstant(termType))); - reified.add(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString().replace("\"", "\\\"")))); - return reified; + // TODO symbol table! + ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); + ctx.addAtom(Atoms.newBasicAtom(CONSTANT_TERM_TYPE, termId, Terms.newConstant(termType))); + ctx.addAtom(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString().replace("\"", "\\\"")))); } - Set reifyVariableTerm(ConstantTerm termId, VariableTerm term) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_VARIABLE)); - reified.add(Atoms.newBasicAtom(VARIABLE_TERM_SYMBOL, termId, Terms.newConstant(term.toString()))); - return reified; + void reifyVariableTerm(ReificationContext ctx, ConstantTerm termId, VariableTerm term) { + ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_VARIABLE)); + ctx.addAtom(Atoms.newBasicAtom(VARIABLE_TERM_SYMBOL, termId, Terms.newConstant(term.toString()))); } - Set reifyArithmeticTerm(ConstantTerm termId, ArithmeticTerm term) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_ARITHMETIC)); - ConstantTerm leftTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_LEFT, termId, leftTermId)); - reified.addAll(reifyTerm(leftTermId, term.getLeftOperand())); - ConstantTerm rightTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_RIGHT, termId, rightTermId)); - reified.addAll(reifyTerm(rightTermId, term.getRightOperand())); - reified.add(Atoms.newBasicAtom(ARITHMETIC_TERM_OPERATOR, termId, Terms.newConstant(term.getOperator().toString()))); - return reified; + void reifyArithmeticTerm(ReificationContext ctx, ConstantTerm termId, ArithmeticTerm term) { + ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_ARITHMETIC)); + ConstantTerm leftTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(ARITHMETIC_TERM_LEFT, termId, leftTermId)); + reifyTerm(ctx, leftTermId, term.getLeftOperand()); + ConstantTerm rightTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(ARITHMETIC_TERM_RIGHT, termId, rightTermId)); + reifyTerm(ctx, rightTermId, term.getRightOperand()); + ctx.addAtom(Atoms.newBasicAtom(ARITHMETIC_TERM_OPERATOR, termId, Terms.newConstant(term.getOperator().toString()))); } - Set reifyFunctionTerm(ConstantTerm termId, FunctionTerm term) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_FUNCTION)); - reified.add(Atoms.newBasicAtom(FUNCTION_TERM_SYMBOL, termId, Terms.newConstant(term.getSymbol()))); - reified.add(Atoms.newBasicAtom(FUNCTION_TERM_NUM_ARGUMENTS, termId, Terms.newConstant(term.getTerms().size()))); + void reifyFunctionTerm(ReificationContext ctx, ConstantTerm termId, FunctionTerm term) { + ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_FUNCTION)); + ctx.addAtom(Atoms.newBasicAtom(FUNCTION_TERM_SYMBOL, termId, Terms.newConstant(term.getSymbol()))); + ctx.addAtom(Atoms.newBasicAtom(FUNCTION_TERM_NUM_ARGUMENTS, termId, Terms.newConstant(term.getTerms().size()))); for (int i = 0; i < term.getTerms().size(); i++) { - ConstantTerm argTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(FUNCTION_TERM_ARGUMENT, termId, Terms.newConstant(i), argTermId)); - reified.addAll(reifyTerm(argTermId, term.getTerms().get(i))); + ConstantTerm argTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(FUNCTION_TERM_ARGUMENT, termId, Terms.newConstant(i), argTermId)); + reifyTerm(ctx, argTermId, term.getTerms().get(i)); } - return reified; } - Set reifyIntervalTerm(ConstantTerm termId, IntervalTerm term) { - Set reified = new LinkedHashSet<>(); - reified.add(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_INTERVAL)); - ConstantTerm lowerTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(INTERVAL_TERM_LOWER, termId, lowerTermId)); - reified.addAll(reifyTerm(lowerTermId, term.getLowerBound())); - ConstantTerm upperTermId = idProvider.getNextId(); - reified.add(Atoms.newBasicAtom(INTERVAL_TERM_UPPER, termId, upperTermId)); - reified.addAll(reifyTerm(upperTermId, term.getUpperBound())); - return reified; + void reifyIntervalTerm(ReificationContext ctx, ConstantTerm termId, IntervalTerm term) { + ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_INTERVAL)); + ConstantTerm lowerTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(INTERVAL_TERM_LOWER, termId, lowerTermId)); + reifyTerm(ctx, lowerTermId, term.getLowerBound()); + ConstantTerm upperTermId = ctx.getNextId(); + ctx.addAtom(Atoms.newBasicAtom(INTERVAL_TERM_UPPER, termId, upperTermId)); + reifyTerm(ctx, upperTermId, term.getUpperBound()); + } + + private static class ReificationContext implements IdGenerator>{ + + private final IdGenerator> idGenerator; + private final Map> predicateTable = new HashMap<>(); + + private final Set reifiedItems = new LinkedHashSet<>(); + + ReificationContext(IdGenerator> idGenerator) { + this.idGenerator = idGenerator; + } + + ConstantTerm computePredicateId(Predicate predicate) { + return predicateTable.computeIfAbsent(predicate, (pred) -> idGenerator.getNextId()); + } + + @Override + public ConstantTerm getNextId() { + return idGenerator.getNextId(); + } + + void addAtom(BasicAtom item) { + reifiedItems.add(item); + } + + Set generatePredicateAtoms() { + Set predicateAtoms = new LinkedHashSet<>(); + for (Map.Entry> entry : predicateTable.entrySet()) { + predicateAtoms.add(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), + Terms.newConstant(entry.getKey().getArity()))); + } + return predicateAtoms; + } + + Set computeReifiedProgram() { + Set reifiedProgram = new LinkedHashSet<>(reifiedItems); + reifiedProgram.addAll(generatePredicateAtoms()); + return reifiedProgram; + } + } } From 2d223090fcffad25f3c4ac8d43c08543756ff5eb Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sat, 22 Oct 2022 21:02:48 +0200 Subject: [PATCH 50/96] improve naming and refactor: AnswerSetQuery -> AtomQuery, reification integration tests --- .../at/ac/tuwien/kr/alpha/api/AnswerSet.java | 3 +- .../tuwien/kr/alpha/api/AnswerSetQuery.java | 82 ---- .../alpha/api/programs/atoms/AtomQuery.java | 68 ++++ .../kr/alpha/commons/BasicAnswerSet.java | 4 +- .../atoms/AtomQueryImpl.java} | 45 ++- .../alpha/commons/programs/atoms/Atoms.java | 9 + .../reification/ReificationContext.java | 54 +++ .../programs/{ => reification}/Reifier.java | 51 +-- .../alpha/commons/programs/ReifierTest.java | 354 ------------------ ...erSetQueryTest.java => AtomQueryTest.java} | 21 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 22 +- .../kr/alpha/api/impl/ReificationTest.java | 120 ++++++ 12 files changed, 300 insertions(+), 533 deletions(-) delete mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AtomQuery.java rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/{util/AnswerSetQueryImpl.java => programs/atoms/AtomQueryImpl.java} (78%) create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/{ => reification}/Reifier.java (93%) delete mode 100644 alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/{AnswerSetQueryTest.java => AtomQueryTest.java} (85%) create mode 100644 alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java index 748e1a781..d5b63f74e 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java @@ -5,6 +5,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; /** * API representation of an answer set, i.e. a set of atoms that is a model of an ASP program. @@ -31,5 +32,5 @@ public interface AnswerSet extends Comparable { /** * List {@link Atom}s in this answer set satisfying the given {@link AnswerSetQuery}. */ - List query(AnswerSetQuery query); + List query(AtomQuery query); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java deleted file mode 100644 index 14aab16a3..000000000 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSetQuery.java +++ /dev/null @@ -1,82 +0,0 @@ -package at.ac.tuwien.kr.alpha.api; - -import java.util.List; - -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.programs.terms.Term; - -/** - * A {@link java.util.function.Predicate} testing {@link Atom}s in order to query {@link AnswerSet}s for {@link Atom}s satisfying a specific - * query. - * - * Copyright (c) 2021, the Alpha Team. - */ -public interface AnswerSetQuery extends java.util.function.Predicate { - - /** - * Adds a filter predicate to apply on terms at the given index position. - * - * @param termIdx the term index on which to apply the new filter - * @param filter a filter predicate - * @return this answer set query withthe given filter added - */ - AnswerSetQuery withFilter(int termIdx, java.util.function.Predicate filter); - - /** - * Convenience method - adds a filter to match names of symbolic constants against a string. - * - * @param termIdx - * @param str - * @return - */ - AnswerSetQuery withConstantEquals(int termIdx, String str); - - /** - * Convenience method - adds a filter to match values of constant terms against a string. - * - * @param termIdx - * @param str - * @return - */ - AnswerSetQuery withStringEquals(int termIdx, String str); - - /** - * Convenience method - adds a filter to check for function terms with a given function symbol and arity. - * - * @param termIdx - * @param funcSymbol - * @param funcArity - * @return - */ - AnswerSetQuery withFunctionTerm(int termIdx, String funcSymbol, int funcArity); - - /** - * Convenience method - adds a filter to check whether a term is equal to a given term. - * - * @param termIdx - * @param otherTerm - * @return - */ - AnswerSetQuery withTermEquals(int termIdx, Term otherTerm); - - /** - * Applies this query to an atom. Filters are worked off in - * order of ascending term index in a conjunctive fashion, i.e. for an atom - * to match the query, all of its terms must satisfy all filters on these - * terms - * - * @param atom the atom to which to apply the query - * @return true iff the atom satisfies the query - */ - @Override - boolean test(Atom atom); - - /** - * Applies this query to an {@link AnswerSet}. - * - * @param as - * @return - */ - List applyTo(AnswerSet as); - -} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AtomQuery.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AtomQuery.java new file mode 100644 index 000000000..2545d274d --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/atoms/AtomQuery.java @@ -0,0 +1,68 @@ +package at.ac.tuwien.kr.alpha.api.programs.atoms; + +import java.util.List; + +import at.ac.tuwien.kr.alpha.api.AnswerSet; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; + +/** + * A query for ASP atoms matching a set of filter predicates. + */ +public interface AtomQuery extends java.util.function.Predicate { + + /** + * Adds a new filter to this AtomQuery. + * For an atom a(t1, ..., tn), the term at index termIdx will be tested against the given filter predicate. + * + * @param termIdx the index of the term to test + * @param filter the test predicate to use on terms + * @return this AtomQuery with the additional filter added + */ + public AtomQuery withFilter(int termIdx, java.util.function.Predicate filter); + + /** + * Convenience method - adds a filter to match names of symbolic constants against a string. + * + * @param termIdx + * @param str + * @return + */ + public AtomQuery withConstantEquals(int termIdx, String str); + + /** + * Convenience method - adds a filter to match values of constant terms against a string. + * + * @param termIdx + * @param str + * @return + */ + public AtomQuery withStringEquals(int termIdx, String str); + + /** + * Convenience method - adds a filter to check for function terms with a given function symbol and arity. + * + * @param termIdx + * @param funcSymbol + * @param funcArity + * @return + */ + public AtomQuery withFunctionTerm(int termIdx, String funcSymbol, int funcArity); + + /** + * Convenience method - adds a filter to check whether a term is equal to a given term. + * + * @param termIdx + * @param otherTerm + * @return + */ + public AtomQuery withTermEquals(int termIdx, Term otherTerm); + + /** + * Applies this query to an {@link AnswerSet}. + * + * @param as + * @return + */ + public List applyTo(AnswerSet as); + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSet.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSet.java index 3dede61cc..c7b006de5 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSet.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/BasicAnswerSet.java @@ -10,9 +10,9 @@ import java.util.SortedSet; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.AnswerSetQuery; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; import at.ac.tuwien.kr.alpha.commons.util.Util; /** @@ -120,7 +120,7 @@ public int compareTo(AnswerSet other) { } @Override - public List query(AnswerSetQuery query) { + public List query(AtomQuery query) { return query.applyTo(this); } } \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java similarity index 78% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java index 146edfd0a..9dfbde0f0 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.util; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import java.util.Collections; import java.util.HashMap; @@ -7,45 +7,49 @@ import java.util.stream.Collectors; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.AnswerSetQuery; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.Predicates; /** * A query for ASP atoms matching a set of filter predicates. */ -public final class AnswerSetQueryImpl implements AnswerSetQuery { +final class AtomQueryImpl implements AtomQuery { private final Predicate predicate; private Map> filters = new HashMap<>(); - private AnswerSetQueryImpl(Predicate pred) { + private AtomQueryImpl(Predicate pred) { this.predicate = pred; } /** - * Creates a new AnswerSetQuery that will match all atoms that are instances of the given {@link Predicate}. + * Creates a new AtomQuery that will match all atoms that are instances of the given {@link Predicate}. * * @param predicate the predicate to match against - * @return a new AnswerSetQuery matching against the given predicate + * @return a new AtomQuery matching against the given predicate */ - public static AnswerSetQueryImpl forPredicate(Predicate predicate) { - return new AnswerSetQueryImpl(predicate); + static AtomQuery forPredicate(Predicate predicate) { + return new AtomQueryImpl(predicate); + } + + static AtomQuery forPredicate(String name, int arity) { + return new AtomQueryImpl(Predicates.getPredicate(name, arity)); } /** - * Adds a new filter to this AnswerSetQuery. + * Adds a new filter to this AtomQuery. * For an atom a(t1, ..., tn), the term at index termIdx will be tested against the given filter predicate. * * @param termIdx the index of the term to test * @param filter the test predicate to use on terms - * @return this AnswerSetQuery with the additional filter added + * @return this AtomQuery with the additional filter added */ - @Override - public AnswerSetQueryImpl withFilter(int termIdx, java.util.function.Predicate filter) { + public AtomQuery withFilter(int termIdx, java.util.function.Predicate filter) { if (termIdx >= this.predicate.getArity()) { throw new IndexOutOfBoundsException( "Predicate " + this.predicate.getName() + " has arity " + this.predicate.getArity() + ", term index " + termIdx + " is invalid!"); @@ -66,9 +70,8 @@ public AnswerSetQueryImpl withFilter(int termIdx, java.util.function.Predicate { if (!(term instanceof ConstantTerm)) { return false; @@ -99,8 +101,7 @@ public AnswerSetQueryImpl withStringEquals(int termIdx, String str) { * @param funcArity * @return */ - @Override - public AnswerSetQueryImpl withFunctionTerm(int termIdx, String funcSymbol, int funcArity) { + public AtomQuery withFunctionTerm(int termIdx, String funcSymbol, int funcArity) { java.util.function.Predicate isFunction = (term) -> { if (!(term instanceof FunctionTerm)) { return false; @@ -124,8 +125,7 @@ public AnswerSetQueryImpl withFunctionTerm(int termIdx, String funcSymbol, int f * @param otherTerm * @return */ - @Override - public AnswerSetQueryImpl withTermEquals(int termIdx, Term otherTerm) { + public AtomQuery withTermEquals(int termIdx, Term otherTerm) { java.util.function.Predicate isEqual = (term) -> { return term.equals(otherTerm); }; @@ -162,7 +162,6 @@ public boolean test(Atom atom) { * @param as * @return */ - @Override public List applyTo(AnswerSet as) { if (!as.getPredicates().contains(this.predicate)) { return Collections.emptyList(); @@ -172,7 +171,7 @@ public List applyTo(AnswerSet as) { private static java.util.function.Predicate constantTermEquals(final String str) { java.util.function.Predicate equalsGivenString = (t) -> { - return AnswerSetQueryImpl.constantTermEquals(t, str); + return AtomQueryImpl.constantTermEquals(t, str); }; return equalsGivenString; } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java index 8c3254e61..8658c58d1 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/Atoms.java @@ -10,6 +10,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; @@ -62,4 +63,12 @@ public static ExternalAtom newExternalAtom(Predicate predicate, PredicateInterpr return new ExternalAtomImpl(predicate, interpretation, input, output); } + public static AtomQuery query(Predicate predicate) { + return AtomQueryImpl.forPredicate(predicate); + } + + public static AtomQuery query(String predicateName, int predicateArity) { + return AtomQueryImpl.forPredicate(predicateName, predicateArity); + } + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java new file mode 100644 index 000000000..98b6bf8be --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java @@ -0,0 +1,54 @@ +package at.ac.tuwien.kr.alpha.commons.programs.reification; + +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; + +import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; + +class ReificationContext implements IdGenerator>{ + + private final IdGenerator> idGenerator; + private final Map> predicateTable = new HashMap<>(); + + private final Set reifiedItems = new LinkedHashSet<>(); + + ReificationContext(IdGenerator> idGenerator) { + this.idGenerator = idGenerator; + } + + ConstantTerm computePredicateId(Predicate predicate) { + return predicateTable.computeIfAbsent(predicate, (pred) -> idGenerator.getNextId()); + } + + @Override + public ConstantTerm getNextId() { + return idGenerator.getNextId(); + } + + void addAtom(BasicAtom item) { + reifiedItems.add(item); + } + + private Set generatePredicateAtoms() { + Set predicateAtoms = new LinkedHashSet<>(); + for (Map.Entry> entry : predicateTable.entrySet()) { + predicateAtoms.add(Atoms.newBasicAtom(Reifier.PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), + Terms.newConstant(entry.getKey().getArity()))); + } + return predicateAtoms; + } + + Set computeReifiedProgram() { + Set reifiedProgram = new LinkedHashSet<>(reifiedItems); + reifiedProgram.addAll(generatePredicateAtoms()); + return reifiedProgram; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java similarity index 93% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java index 7e8f63954..58f97e128 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.commons.programs; +package at.ac.tuwien.kr.alpha.commons.programs.reification; import java.util.HashMap; import java.util.LinkedHashSet; @@ -207,12 +207,7 @@ public Set reifyProgram(ASPCore2Program program) { } reifyRule(ctx, rule); } - // TODO do this in context! - for (Map.Entry> entry : reifiedPredicates.entrySet()) { - ctx.addAtom(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), - Terms.newConstant(entry.getKey().getArity()))); - } - return ctx.reifiedProgram(); + return ctx.computeReifiedProgram(); } /** @@ -406,7 +401,6 @@ void reifyConstantTerm(ReificationContext ctx, ConstantTerm termId, ConstantT } else { termType = TERM_TYPES.getOrDefault(term.getObject().getClass(), "object(" + term.getObject().getClass().getName() + ")"); } - // TODO symbol table! ctx.addAtom(Atoms.newBasicAtom(TERM_TYPE, termId, TERM_TYPE_CONSTANT)); ctx.addAtom(Atoms.newBasicAtom(CONSTANT_TERM_TYPE, termId, Terms.newConstant(termType))); ctx.addAtom(Atoms.newBasicAtom(CONSTANT_TERM_VALUE, termId, Terms.newConstant(term.getObject().toString().replace("\"", "\\\"")))); @@ -449,45 +443,4 @@ void reifyIntervalTerm(ReificationContext ctx, ConstantTerm termId, IntervalT reifyTerm(ctx, upperTermId, term.getUpperBound()); } - private static class ReificationContext implements IdGenerator>{ - - private final IdGenerator> idGenerator; - private final Map> predicateTable = new HashMap<>(); - - private final Set reifiedItems = new LinkedHashSet<>(); - - ReificationContext(IdGenerator> idGenerator) { - this.idGenerator = idGenerator; - } - - ConstantTerm computePredicateId(Predicate predicate) { - return predicateTable.computeIfAbsent(predicate, (pred) -> idGenerator.getNextId()); - } - - @Override - public ConstantTerm getNextId() { - return idGenerator.getNextId(); - } - - void addAtom(BasicAtom item) { - reifiedItems.add(item); - } - - Set generatePredicateAtoms() { - Set predicateAtoms = new LinkedHashSet<>(); - for (Map.Entry> entry : predicateTable.entrySet()) { - predicateAtoms.add(Atoms.newBasicAtom(PREDICATE, entry.getValue(), Terms.newConstant(entry.getKey().getName()), - Terms.newConstant(entry.getKey().getArity()))); - } - return predicateAtoms; - } - - Set computeReifiedProgram() { - Set reifiedProgram = new LinkedHashSet<>(reifiedItems); - reifiedProgram.addAll(generatePredicateAtoms()); - return reifiedProgram; - } - - } - } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java deleted file mode 100644 index d56a1aa3c..000000000 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/ReifierTest.java +++ /dev/null @@ -1,354 +0,0 @@ -package at.ac.tuwien.kr.alpha.commons.programs; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; - -import org.junit.jupiter.api.Test; - -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; -import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; -import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; -import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; -import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; -import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; - -public class ReifierTest { - - private IdGenerator> newIdGenerator() { - final IntIdGenerator idGen = new IntIdGenerator(0); - return () -> Terms.newConstant(idGen.getNextId()); - } - - @Test - public void reifySymbolicConstant() { - ConstantTerm constant = Terms.newSymbolicConstant("someConstant"); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("symbol")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someConstant")))); - } - - @Test - public void reifyStringConstant() { - ConstantTerm constant = Terms.newConstant("someString"); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someString")))); - } - - @Test - public void reifyStringWithQuotes() { - ConstantTerm constant = Terms.newConstant("someStringWith\"Quotes\""); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("string")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant("someStringWith\\\"Quotes\\\"")))); - - } - - @Test - public void reifyIntegerConstant() { - ConstantTerm constant = Terms.newConstant(666); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyConstantTerm(reifiedId, constant); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("constant")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_type", 2), reifiedId, Terms.newConstant("integer")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("constantTerm_value", 2), reifiedId, Terms.newConstant(Integer.toString(666))))); - } - - @Test - public void reifyVariable() { - VariableTerm var = Terms.newVariable("SOME_VAR"); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyVariableTerm(reifiedId, var); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("variable")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("variableTerm_symbol", 2), reifiedId, Terms.newConstant("SOME_VAR")))); - } - - @Test - public void reifyArithmeticTerm() { - Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyArithmeticTerm(reifiedId, (ArithmeticTerm) arithmeticTerm); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("arithmetic")))); - assertTrue(reified.contains( - Atoms.newBasicAtom(Predicates.getPredicate("arithmeticTerm_operator", 2), reifiedId, Terms.newConstant(ArithmeticOperator.PLUS.toString())))); - assertTrue(reified.stream() - .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("arithmeticTerm_leftTerm", 2))) - .findFirst() - .isPresent()); - assertTrue(reified.stream() - .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("arithmeticTerm_rightTerm", 2))) - .findFirst() - .isPresent()); - } - - @Test - public void reifyFunctionTerm() { - FunctionTerm funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyFunctionTerm(reifiedId, funcTerm); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), reifiedId, Terms.newSymbolicConstant("function")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_symbol", 2), reifiedId, Terms.newConstant("f")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("functionTerm_numArguments", 2), reifiedId, Terms.newConstant(1)))); - assertEquals(1, reified.stream() - .filter((atom) -> atom.getPredicate().equals(Predicates.getPredicate("functionTerm_argumentTerm", 3))) - .collect(Collectors.toList()).size()); - } - - @Test - public void reifyTerm() { - Term constTerm = Terms.newConstant("bla"); - Term varTerm = Terms.newVariable("VAR"); - Term arithmeticTerm = Terms.newArithmeticTerm(Terms.newVariable("VAR"), ArithmeticOperator.PLUS, Terms.newConstant(2)); - Term funcTerm = Terms.newFunctionTerm("f", Terms.newConstant(1)); - - IdGenerator> idGen = newIdGenerator(); - Reifier reificationHelper = new Reifier(idGen); - - ConstantTerm constId = idGen.getNextId(); - Set reifiedConst = reificationHelper.reifyTerm(constId, constTerm); - assertTrue(reifiedConst.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), constId, Terms.newSymbolicConstant("constant")))); - - ConstantTerm varId = idGen.getNextId(); - Set reifiedVar = reificationHelper.reifyTerm(varId, varTerm); - assertTrue(reifiedVar.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), varId, Terms.newSymbolicConstant("variable")))); - - ConstantTerm calcId = idGen.getNextId(); - Set reifiedCalc = reificationHelper.reifyTerm(calcId, arithmeticTerm); - assertTrue(reifiedCalc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), calcId, Terms.newSymbolicConstant("arithmetic")))); - - ConstantTerm funcId = idGen.getNextId(); - Set reifiedFunc = reificationHelper.reifyTerm(funcId, funcTerm); - assertTrue(reifiedFunc.contains(Atoms.newBasicAtom(Predicates.getPredicate("term_type", 2), funcId, Terms.newSymbolicConstant("function")))); - } - - @Test - public void reifyBasicAtom() { - BasicAtom atom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyBasicAtom(reifiedId, atom); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("basic")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("basicAtom_numTerms", 2), reifiedId, Terms.newConstant(2)))); - assertEquals(2, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("basicAtom_term", 3))) - .collect(Collectors.toList()) - .size()); - } - - @Test - public void reifyComparisonAtom() { - ComparisonAtom atom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyComparisonAtom(reifiedId, atom); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("comparison")))); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("comparisonAtom_leftTerm", 2))) - .collect(Collectors.toList()) - .size()); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("comparisonAtom_rightTerm", 2))) - .collect(Collectors.toList()) - .size()); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("comparisonAtom_operator", 2), reifiedId, Terms.newSymbolicConstant("le")))); - } - - @Test - public void reifyAggregateElement() { - List elementTerms = new ArrayList<>(); - elementTerms.add(Terms.newVariable("X")); - List elementLiterals = new ArrayList<>(); - elementLiterals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom", 1), Terms.newVariable("X")).toLiteral()); - AggregateElement element = Atoms.newAggregateElement(elementTerms, elementLiterals); - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyAggregateElement(reifiedId, element); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numTerms", 2), reifiedId, Terms.newConstant(1)))); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateElement_term", 3))) - .collect(Collectors.toList()) - .size()); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateElement_numLiterals", 2), reifiedId, Terms.newConstant(1)))); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateElement_literal", 2))) - .collect(Collectors.toList()) - .size()); - } - - @Test - public void reifyAggregateAtom() { - List element1Terms = new ArrayList<>(); - element1Terms.add(Terms.newVariable("X")); - List element1Literals = new ArrayList<>(); - element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); - AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); - - List element2Terms = new ArrayList<>(); - element1Terms.add(Terms.newVariable("Y")); - List element2Literals = new ArrayList<>(); - element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); - AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); - - List elements = new ArrayList<>(); - elements.add(element1); - elements.add(element2); - AggregateAtom atom = Atoms.newAggregateAtom(ComparisonOperators.EQ, Terms.newVariable("X"), AggregateFunctionSymbol.COUNT, elements); - - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyAggregateAtom(reifiedId, atom); - - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("aggregate")))); - assertTrue(reified - .contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateAtom_aggregateFunction", 2), reifiedId, Terms.newSymbolicConstant("count")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("aggregateAtom_numAggregateElements", 2), reifiedId, Terms.newConstant(2)))); - assertEquals(2, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("aggregateAtom_aggregateElement", 2))) - .collect(Collectors.toList()) - .size()); - } - - @Test - public void reifyExternalAtom() { - List extInput = new ArrayList<>(); - List extOutput = new ArrayList<>(); - extInput.add(Terms.newVariable("I")); - extOutput.add(Terms.newVariable("O")); - ExternalAtom atom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); - - IdGenerator> idGen = newIdGenerator(); - ConstantTerm reifiedId = idGen.getNextId(); - Set reified = new Reifier(idGen).reifyExternalAtom(reifiedId, atom); - - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedId, Terms.newSymbolicConstant("external")))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("externalAtom_numInputTerms", 2), reifiedId, Terms.newConstant(1)))); - assertTrue(reified.contains(Atoms.newBasicAtom(Predicates.getPredicate("externalAtom_numOutputTerms", 2), reifiedId, Terms.newConstant(1)))); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_name", 2))) - .collect(Collectors.toList()) - .size()); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_inputTerm", 3))) - .collect(Collectors.toList()) - .size()); - assertEquals(1, - reified.stream() - .filter( - (a) -> a.getPredicate().equals(Predicates.getPredicate("externalAtom_outputTerm", 3))) - .collect(Collectors.toList()) - .size()); - } - - @Test - public void reifyAtom() { - Atom basicAtom = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), Terms.newVariable("X"), Terms.newVariable("Y")); - - Atom cmpAtom = Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("X"), ComparisonOperators.LE); - - List element1Terms = new ArrayList<>(); - element1Terms.add(Terms.newVariable("X")); - List element1Literals = new ArrayList<>(); - element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom1", 1), Terms.newVariable("X")).toLiteral()); - AggregateElement element1 = Atoms.newAggregateElement(element1Terms, element1Literals); - List element2Terms = new ArrayList<>(); - element1Terms.add(Terms.newVariable("Y")); - List element2Literals = new ArrayList<>(); - element1Literals.add(Atoms.newBasicAtom(Predicates.getPredicate("dom2", 1), Terms.newVariable("Y")).toLiteral()); - AggregateElement element2 = Atoms.newAggregateElement(element2Terms, element2Literals); - List elements = new ArrayList<>(); - elements.add(element1); - elements.add(element2); - Atom aggAtom = Atoms.newAggregateAtom(ComparisonOperators.EQ, Terms.newVariable("X"), AggregateFunctionSymbol.COUNT, elements); - - List extInput = new ArrayList<>(); - List extOutput = new ArrayList<>(); - extInput.add(Terms.newVariable("I")); - extOutput.add(Terms.newVariable("O")); - ExternalAtom extAtom = Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), (trms) -> Collections.emptySet(), extInput, extOutput); - - IdGenerator> idGen = newIdGenerator(); - - ConstantTerm reifiedBasicAtomId = idGen.getNextId(); - Set reifiedBasicAtom = new Reifier(idGen).reifyAtom(reifiedBasicAtomId, basicAtom); - assertTrue(reifiedBasicAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedBasicAtomId, Terms.newSymbolicConstant("basic")))); - - ConstantTerm reifiedCmpAtomId = idGen.getNextId(); - Set reifiedCmpAtom = new Reifier(idGen).reifyAtom(reifiedCmpAtomId, cmpAtom); - assertTrue(reifiedCmpAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedCmpAtomId, Terms.newSymbolicConstant("comparison")))); - - ConstantTerm reifiedAggAtomId = idGen.getNextId(); - Set reifiedAggAtom = new Reifier(idGen).reifyAtom(reifiedAggAtomId, aggAtom); - assertTrue(reifiedAggAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedAggAtomId, Terms.newSymbolicConstant("aggregate")))); - - ConstantTerm reifiedExtAtomId = idGen.getNextId(); - Set reifiedExtAtom = new Reifier(idGen).reifyAtom(reifiedExtAtomId, extAtom); - assertTrue(reifiedExtAtom.contains(Atoms.newBasicAtom(Predicates.getPredicate("atom_type", 2), reifiedExtAtomId, Terms.newSymbolicConstant("external")))); - } - - @Test - public void reifyDirectives() { - InlineDirectives directives = Programs.newInlineDirectives(); - directives.addDirective(InlineDirectives.DIRECTIVE.enum_predicate_is, "bla"); - ASPCore2Program program = Programs.builder() - .addRule(Rules.newRule( - Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("a", 0))), - Atoms.newBasicAtom(Predicates.getPredicate("b", 0)).toLiteral())) - .addInlineDirectives(directives) - .build(); - Set reified = new Reifier(newIdGenerator()).reifyProgram(program); - assertTrue(reified.contains(Atoms.newBasicAtom(Reifier.INLINE_DIRECTIVE, Terms.newConstant("enum_predicate_is"), Terms.newConstant("bla")))); - } -} diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AtomQueryTest.java similarity index 85% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AtomQueryTest.java index a2775aa24..b7dcc1859 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AnswerSetQueryTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/util/AtomQueryTest.java @@ -14,6 +14,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; @@ -22,7 +23,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -public class AnswerSetQueryTest { +public class AtomQueryTest { @Test public void matchPredicate() { @@ -35,7 +36,7 @@ public void matchPredicate() { .symbolicInstance("x"); //@formatter:on AnswerSet as = bld.build(); - List queryResult = as.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("p", 1))); + List queryResult = as.query(Atoms.query(Predicates.getPredicate("p", 1))); assertEquals(2, queryResult.size()); for (Atom a : queryResult) { assertTrue(a.getPredicate().equals(Predicates.getPredicate("p", 1))); @@ -49,8 +50,7 @@ public void matchSymbolicConstant() { .symbolicInstance("a") .instance("a"); AnswerSet as = bld.build(); - AnswerSetQueryImpl constantQuery = AnswerSetQueryImpl - .forPredicate(Predicates.getPredicate("p", 1)) + AtomQuery constantQuery = Atoms.query(Predicates.getPredicate("p", 1)) .withConstantEquals(0, "a"); List queryResult = as.query(constantQuery); assertEquals(1, queryResult.size()); @@ -63,8 +63,7 @@ public void matchString() { .symbolicInstance("a") .instance("a"); AnswerSet as = bld.build(); - AnswerSetQueryImpl stringQuery = AnswerSetQueryImpl - .forPredicate(Predicates.getPredicate("p", 1)) + AtomQuery stringQuery = Atoms.query(Predicates.getPredicate("p", 1)) .withStringEquals(0, "a"); List queryResult = as.query(stringQuery); assertEquals(1, queryResult.size()); @@ -84,7 +83,7 @@ public void matchEvenIntegers() { String strValue = ((ConstantTerm) term).getObject().toString(); return strValue.matches("[0-9]+"); }; - AnswerSetQueryImpl evenIntegers = AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("p", 1)) + AtomQuery evenIntegers = Atoms.query(Predicates.getPredicate("p", 1)) .withFilter(0, isInteger.and( (term) -> Integer.valueOf(((ConstantTerm) term).getObject().toString()) % 2 == 0)); List queryResult = as.query(evenIntegers); @@ -114,11 +113,11 @@ public void matchXWithFuncTerm() { ps.add(a5); instances.put(p, ps); AnswerSet as = AnswerSets.newAnswerSet(predicates, instances); - AnswerSetQueryImpl query = AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("p", 2)).withConstantEquals(0, "x").withFunctionTerm(1, "f", 1); + AtomQuery query = Atoms.query(Predicates.getPredicate("p", 2)).withConstantEquals(0, "x").withFunctionTerm(1, "f", 1); List queryResult = as.query(query); assertEquals(2, queryResult.size()); } - + @Test public void matchTerm() { AnswerSetBuilder bld = new AnswerSetBuilder(); @@ -126,8 +125,8 @@ public void matchTerm() { .instance(1).instance(2).instance(3).instance(4).instance(5) .instance("bla").symbolicInstance("blubb"); AnswerSet as = bld.build(); - - AnswerSetQueryImpl equalTerm = AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("p", 1)).withTermEquals(0, Terms.newConstant(1)); + + AtomQuery equalTerm = Atoms.query(Predicates.getPredicate("p", 1)).withTermEquals(0, Terms.newConstant(1)); List queryResult = as.query(equalTerm); assertEquals(1, queryResult.size()); Atom retrievedAtom = queryResult.get(0); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 4c8c21b0b..e359284a1 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -63,8 +63,9 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; -import at.ac.tuwien.kr.alpha.commons.programs.Reifier; +import at.ac.tuwien.kr.alpha.commons.programs.reification.Reifier; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.common.AtomStore; @@ -83,14 +84,20 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); - private SystemConfig config = new SystemConfig(); // Config is initialized with default values. - private ProgramParser parser = new ProgramParserImpl(); + private final SystemConfig config; // Config is initialized with default values. + private final ProgramParser parser = new ProgramParserImpl(); + private final Reifier reifier = new Reifier(() -> { + IdGenerator idGen = new IntIdGenerator(0); + return () -> Terms.newConstant(idGen.getNextId()); + }); + public AlphaImpl(SystemConfig cfg) { this.config = cfg; } public AlphaImpl() { + this.config = new SystemConfig(); } @Override @@ -225,10 +232,6 @@ private Solver prepareSolverFor(CompiledProgram program, java.util.function.Pred return SolverFactory.getInstance(config, atomStore, grounder); } - public void setConfig(SystemConfig config) { - this.config = config; - } - @Override public DebugSolvingContext prepareDebugSolve(ASPCore2Program program) { return prepareDebugSolve(program, InputConfig.DEFAULT_FILTER); @@ -299,10 +302,7 @@ public Solver prepareSolverFor(NormalProgram program, java.util.function.Predica @Override public Set reify(ASPCore2Program program) { - final IntIdGenerator intIdGen = new IntIdGenerator(0); - return new Reifier(() -> { - return Terms.newConstant(intIdGen.getNextId()); - }).reifyProgram(program); + return reifier.reifyProgram(program); } } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java new file mode 100644 index 000000000..678d9617e --- /dev/null +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -0,0 +1,120 @@ +package at.ac.tuwien.kr.alpha.api.impl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.junit.jupiter.api.Test; + +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; + +/** + * Integration tests for program reification, i.e. generating sets of facts describing arbitrary ASP programs. + */ +public class ReificationTest { + + private final Alpha alpha = new AlphaImpl(); + + @Test + public void propositionalFact() { + Set reified = alpha.reify(alpha.readProgramString("aRatherUselessFact.")); + List factAtomResult = reified.stream().filter(Atoms.query("fact", 1)).collect(Collectors.toList()); + assertEquals(1, factAtomResult.size()); + BasicAtom factAtom = factAtomResult.get(0); + Term idTerm = factAtom.getTerms().get(0); + assertTrue(reified.stream().filter( + Atoms.query("atom_type", 2) + .withTermEquals(0, idTerm) + .withTermEquals(1, Terms.newSymbolicConstant("basic"))) + .findFirst() + .isPresent()); + assertTrue(reified.stream().filter( + Atoms.query("basicAtom_numTerms", 2) + .withTermEquals(0, idTerm) + .withTermEquals(1, Terms.newConstant(0))) + .findFirst() + .isPresent()); + Optional predicateAtomResult = reified.stream().filter(Atoms.query("basicAtom_predicate", 2) + .withTermEquals(0, idTerm)).findFirst(); + assertTrue(predicateAtomResult.isPresent()); + Term predicateIdTerm = predicateAtomResult.get().getTerms().get(1); + Optional predicateDescriptorResult = reified.stream().filter(Atoms.query("predicate", 3) + .withTermEquals(0, predicateIdTerm)).findFirst(); + assertTrue(predicateDescriptorResult.isPresent()); + BasicAtom predicateDescriptor = predicateDescriptorResult.get(); + assertEquals(Terms.newConstant("aRatherUselessFact"), predicateDescriptor.getTerms().get(1)); + assertEquals(Terms.newConstant(0), predicateDescriptor.getTerms().get(2)); + } + + @Test + public void simplePositiveRule() { + Set reified = alpha.reify(alpha.readProgramString("p(X) :- q(X), r(X).")); + List ruleDescriptorResult = reified.stream().filter(Atoms.query("rule", 1)).collect(Collectors.toList()); + assertEquals(1, ruleDescriptorResult.size()); + BasicAtom ruleDescriptor = ruleDescriptorResult.get(0); + Term ruleId = ruleDescriptor.getTerms().get(0); + List headDescriptorResult = reified.stream().filter( + Atoms.query("rule_head", 2) + .withTermEquals(0, ruleId)) + .collect(Collectors.toList()); + assertEquals(1, headDescriptorResult.size()); + BasicAtom headDescriptor = headDescriptorResult.get(0); + Term headId = headDescriptor.getTerms().get(1); + assertEquals(1, reified.stream().filter( + Atoms.query("head_type", 2) + .withTermEquals(0, headId) + .withTermEquals(1, Terms.newSymbolicConstant("normal"))) + .collect(Collectors.toList()).size()); + List headAtomDescriptorResult = reified.stream().filter( + Atoms.query("normalHead_atom", 2) + .withTermEquals(0, headId)) + .collect(Collectors.toList()); + assertEquals(1, headAtomDescriptorResult.size()); + BasicAtom headAtomDescriptor = headAtomDescriptorResult.get(0); + Term headAtomId = headAtomDescriptor.getTerms().get(1); + Set atomTypeDescriptors = reified.stream().filter( + Atoms.query("atom_type", 2) + .withTermEquals(1, Terms.newSymbolicConstant("basic"))) + .collect(Collectors.toSet()); + assertEquals(3, atomTypeDescriptors.size()); + assertEquals(1, atomTypeDescriptors.stream().filter(Atoms.query("atom_type", 2).withTermEquals(0, headAtomId)).collect(Collectors.toList()).size()); + assertEquals(1, reified.stream().filter( + Atoms.query("rule_numBodyLiterals", 2) + .withTermEquals(0, ruleId) + .withTermEquals(1, Terms.newConstant(2))) + .collect(Collectors.toList()).size()); + Set bodyLiteralDescriptors = reified.stream().filter( + Atoms.query("rule_bodyLiteral", 2) + .withTermEquals(0, ruleId)) + .collect(Collectors.toSet()); + assertEquals(2, bodyLiteralDescriptors.size()); + for (BasicAtom bodyLiteralDescriptor : bodyLiteralDescriptors) { + assertEquals(1, reified.stream().filter( + Atoms.query("literal_polarity", 2) + .withTermEquals(0, bodyLiteralDescriptor.getTerms().get(1)) + .withTermEquals(1, Terms.newSymbolicConstant("pos"))) + .collect(Collectors.toList()).size()); + assertEquals(1, reified.stream().filter( + Atoms.query("literal_atom", 2) + .withTermEquals(0, bodyLiteralDescriptor.getTerms().get(1))) + .collect(Collectors.toList()).size()); + } + assertEquals(3, reified.stream().filter( + Atoms.query("term_type", 2) + .withTermEquals(1, Terms.newSymbolicConstant("variable"))) + .collect(Collectors.toSet()).size()); + assertEquals(3,reified.stream().filter( + Atoms.query("variableTerm_symbol", 2) + .withTermEquals(1, Terms.newConstant("X"))) + .collect(Collectors.toSet()).size()); + } + +} From fee81a86398741e842988c8a206f99edc37012f2 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Fri, 2 Dec 2022 05:22:18 +0100 Subject: [PATCH 51/96] Improve logging output for debugging. --- .../tuwien/kr/alpha/core/common/NoGood.java | 21 ++++++++----- .../core/solver/NoGoodStoreAlphaRoaming.java | 2 +- .../kr/alpha/core/solver/TrailAssignment.java | 31 ++++++++++--------- 3 files changed, 31 insertions(+), 23 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java index 3575669ba..3705b0c18 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/common/NoGood.java @@ -27,6 +27,14 @@ */ package at.ac.tuwien.kr.alpha.core.common; +import at.ac.tuwien.kr.alpha.commons.util.Util; +import at.ac.tuwien.kr.alpha.core.solver.Antecedent; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.stream.IntStream; + import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isNegated; import static at.ac.tuwien.kr.alpha.core.atoms.Literals.isPositive; @@ -37,14 +45,6 @@ import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.STATIC; import static at.ac.tuwien.kr.alpha.core.common.NoGoodInterface.Type.SUPPORT; -import java.util.Arrays; -import java.util.Iterator; -import java.util.List; -import java.util.stream.IntStream; - -import at.ac.tuwien.kr.alpha.commons.util.Util; -import at.ac.tuwien.kr.alpha.core.solver.Antecedent; - public class NoGood implements NoGoodInterface, Comparable { public static final int HEAD = 0; public static final NoGood UNSAT = new NoGood(); @@ -163,6 +163,11 @@ public void bumpActivity() { @Override public void decreaseActivity() { } + + @Override + public String toString() { + return NoGood.this + "(unwatched)"; + } }; } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java index 8b4d1977e..4e80e769f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/NoGoodStoreAlphaRoaming.java @@ -774,7 +774,7 @@ public int size() { @Override public String toString() { - return "BinaryWatchList(" + forLiteral + ")"; + return "BinaryWatchList(" + literalToString(forLiteral) + ")"; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java index 9194925d8..10716621d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java @@ -27,6 +27,19 @@ */ package at.ac.tuwien.kr.alpha.core.solver; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.core.common.Assignment; +import at.ac.tuwien.kr.alpha.core.common.AtomStore; +import at.ac.tuwien.kr.alpha.core.common.IntIterator; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + import static at.ac.tuwien.kr.alpha.commons.util.Util.arrayGrowthSize; import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; @@ -37,20 +50,6 @@ import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.MBT; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.TRUE; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.core.common.Assignment; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.IntIterator; - /** * An implementation of Assignment using a trail (of literals) and arrays as underlying structures for storing * assignments. @@ -73,7 +72,11 @@ public void bumpActivity() { @Override public void decreaseActivity() { + } + @Override + public String toString() { + return "ClosingIndicatorAntecedent"; } }; From 0a319f4a3cc1e47ee0a1f673e7d1e7fdfa041025 Mon Sep 17 00:00:00 2001 From: Lorenz Leutgeb Date: Tue, 6 Dec 2022 13:29:20 +0100 Subject: [PATCH 52/96] ci: Update Java Versions --- .github/workflows/build.yml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1902bcbfe..33f57a67b 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -8,19 +8,22 @@ jobs: # We test against Java releases: # - greater than 7 # AND - # - with LTS and in "Premier Support" phase + # - with LTS and at least in Oracle's "Extended Support" phase # OR # - not succeeded by any other release + # # No Oracle JDK >11, see # https://blogs.oracle.com/java-platform-group/oracle-jdk-releases-for-java-11-and-later # https://www.oracle.com/technetwork/java/java-se-support-roadmap.html java: - # LTS and in "Premier Support" as of 2019-03 (until 2022-03) + # LTS with Oracle "Extended Support" until 2030-12 - 8 - # LTS and in "Premier Support" as of 2019-03 (until 2023-09) + # LTS with Oracle "Extended Support" until 2026-09 - 11 - # LTS as of 2021-11 (until 2029) + # LTS with Oracle "Extended Support" until 2029-09 - 17 + # Not succeeded as of 2022-12 + - 19 os: [ubuntu, windows] env: # We only post coverage data for exactly one build to coveralls. From 1afecb8192b27bc99e1f9a8b2f67e80e752cd830 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 11 Dec 2022 13:53:17 +0100 Subject: [PATCH 53/96] fix checkstyle violations --- .../alpha/commons/programs/reification/ReificationContext.java | 2 +- .../tuwien/kr/alpha/commons/programs/reification/Reifier.java | 1 - .../java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java index 98b6bf8be..a5034ef9a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/ReificationContext.java @@ -12,7 +12,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; -class ReificationContext implements IdGenerator>{ +class ReificationContext implements IdGenerator> { private final IdGenerator> idGenerator; private final Map> predicateTable = new HashMap<>(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java index 58f97e128..040e1be4a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java @@ -1,7 +1,6 @@ package at.ac.tuwien.kr.alpha.commons.programs.reification; import java.util.HashMap; -import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; import java.util.function.Supplier; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java index 678d9617e..952474fc4 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -111,7 +111,7 @@ public void simplePositiveRule() { Atoms.query("term_type", 2) .withTermEquals(1, Terms.newSymbolicConstant("variable"))) .collect(Collectors.toSet()).size()); - assertEquals(3,reified.stream().filter( + assertEquals(3, reified.stream().filter( Atoms.query("variableTerm_symbol", 2) .withTermEquals(1, Terms.newConstant("X"))) .collect(Collectors.toSet()).size()); From c4ce84a02d6f94db26db923abee9e56f6e121126 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 12 Dec 2022 20:09:29 +0100 Subject: [PATCH 54/96] parsing method for atom sets for use in testing --- .../kr/alpha/api/impl/AnswerSetsParser.java | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java index a197d62e8..a17db4700 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java @@ -2,6 +2,8 @@ import java.util.Collections; import java.util.Set; +import java.util.TreeSet; +import java.util.stream.Collectors; import org.antlr.v4.runtime.BailErrorStrategy; import org.antlr.v4.runtime.CharStream; @@ -12,10 +14,13 @@ import org.antlr.v4.runtime.misc.ParseCancellationException; import at.ac.tuwien.kr.alpha.api.AnswerSet; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.parser.ParseTreeVisitor; +// TODO this class should be called something different since it's turning into a general "atom set snippet parser" // TODO this is duplicated from core module, need to pull out test utils into separate testsupport module public class AnswerSetsParser { @@ -42,4 +47,31 @@ public static Set parse(CharStream stream) { return VISITOR.translate(parser.answer_sets()); } + + public static Set parseAtoms(String s) { + Set tmp = parse(s); + if(tmp.size() > 1) { + throw new IllegalArgumentException("Cannot parse multiset of atoms! Use answer set parsing methods instead!"); + } + if(tmp.isEmpty()) { + return Collections.emptySet(); + } + AnswerSet as = tmp.stream().findFirst().get(); + Set atoms = as.getPredicates() + .stream() + .map( + (pred) -> as.getPredicateInstances(pred).stream() + .map((atom) -> { + if(!(atom instanceof BasicAtom)) { + throw new IllegalArgumentException("Expected a BasicAtom, but got: " + atom); + } + return (BasicAtom) atom; + }).collect(Collectors.toSet()) + ) + .reduce(new TreeSet(), (result, element) -> { + result.addAll(element); + return result; + }); + return atoms; + } } From 38e27b8bc3d3cc9e7a86cdbcf2f5eae49fbea9f7 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 12 Dec 2022 20:12:30 +0100 Subject: [PATCH 55/96] remove unused import --- .../java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java | 1 - 1 file changed, 1 deletion(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java index a17db4700..e4d32a628 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java @@ -14,7 +14,6 @@ import org.antlr.v4.runtime.misc.ParseCancellationException; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; From 23b6948e4edc27e8f63fc44de94990ad2c555346 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Wed, 14 Dec 2022 18:14:02 +0100 Subject: [PATCH 56/96] WIP: tests for reification --- .../kr/alpha/api/impl/AnswerSetsParser.java | 2 +- .../kr/alpha/api/impl/ReificationTest.java | 99 ++++++++++++++++++- 2 files changed, 99 insertions(+), 2 deletions(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java index e4d32a628..dd4d8bdaf 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AnswerSetsParser.java @@ -48,7 +48,7 @@ public static Set parse(CharStream stream) { } public static Set parseAtoms(String s) { - Set tmp = parse(s); + Set tmp = parse("{" + s + "}"); if(tmp.size() > 1) { throw new IllegalArgumentException("Cannot parse multiset of atoms! Use answer set parsing methods instead!"); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java index 952474fc4..77348249e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -7,12 +7,19 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.ComparisonOperator; +import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; @@ -55,7 +62,7 @@ public void propositionalFact() { } @Test - public void simplePositiveRule() { + public void positiveRule() { Set reified = alpha.reify(alpha.readProgramString("p(X) :- q(X), r(X).")); List ruleDescriptorResult = reified.stream().filter(Atoms.query("rule", 1)).collect(Collectors.toList()); assertEquals(1, ruleDescriptorResult.size()); @@ -117,4 +124,94 @@ public void simplePositiveRule() { .collect(Collectors.toSet()).size()); } + @Test + public void ruleWithNegativeLiteral() { + Set reified = alpha.reify(alpha.readProgramString("p(X) :- q(X), not r(X).")); + List> qIds = findLiteralIdsForPredicate(Predicates.getPredicate("q", 1), Terms.newConstant(0), reified); + assertEquals(1, qIds.size()); + assertEquals(1, + reified.stream().filter( + Atoms.query("literal_polarity", 2) + .withTermEquals(0, qIds.get(0)) + .withTermEquals(1, Terms.newSymbolicConstant("pos"))) + .collect(Collectors.toList()) + .size() + ); + List> rIds = findLiteralIdsForPredicate(Predicates.getPredicate("r", 1), Terms.newConstant(0), reified); + assertEquals(1, rIds.size()); + assertEquals(1, + reified.stream().filter( + Atoms.query("literal_polarity", 2) + .withTermEquals(0, rIds.get(0)) + .withTermEquals(1, Terms.newSymbolicConstant("neg"))) + .collect(Collectors.toList()) + .size() + ); + } + + @Test + public void comparisonAtom() { + Set reified = alpha.reify(alpha.readProgramString("p(X) :- X = 42.")); + + } + + private static List> findLiteralIdsForPredicate(Predicate predicate, ConstantTerm reifiedRuleId, Set reifiedProgram) { + ConstantTerm predicateId = findPredicateId(predicate, reifiedProgram); + return ruleBodyLiteralIdStream(reifiedRuleId, reifiedProgram) + .filter((literalId) -> { + List> atomIdResult = reifiedProgram.stream() + .filter(Atoms.query("literal_atom", 2).withTermEquals(0, literalId)) + .map((literalToAtomDescriptor) -> (ConstantTerm) literalToAtomDescriptor.getTerms().get(1)) + .collect(Collectors.toList()); + if (atomIdResult.isEmpty()) { + return false; + } + ConstantTerm atomId = atomIdResult.get(0); + List> predicateIdOfBasicAtomResult = reifiedProgram.stream() + .filter(Atoms.query("basicAtom_predicate", 2).withTermEquals(0, atomId)) + .map((atomToPredicateDescriptor) -> (ConstantTerm) atomToPredicateDescriptor.getTerms().get(1)) + .collect(Collectors.toList()); + return predicateIdOfBasicAtomResult.isEmpty() ? false : predicateIdOfBasicAtomResult.get(0).equals(predicateId); + }) + .collect(Collectors.toList()); + } + + private static List> findLiteralIdsForComparisonOperator(ComparisonOperator operator, ConstantTerm reifiedRuleId, Set reifiedProgram) { + return ruleBodyLiteralIdStream(reifiedRuleId, reifiedProgram) + .filter((literalId) -> { + List> atomIdResult = reifiedProgram.stream() + .filter(Atoms.query("literal_atom", 2).withTermEquals(0, literalId)) + .map((literalToAtomDescriptor) -> (ConstantTerm) literalToAtomDescriptor.getTerms().get(1)) + .collect(Collectors.toList()); + if (atomIdResult.isEmpty()) { + return false; + } + ConstantTerm atomId = atomIdResult.get(0); + return false; // TODO! + }).collect(Collectors.toList()); // TODO + } + + private static ConstantTerm findPredicateId(Predicate predicate, Set reifiedProgram) { + List reifiedPredicateResult = reifiedProgram.stream() + .filter(queryForReifiedPredicate(predicate)) + .collect(Collectors.toList()); + if(reifiedPredicateResult.size() > 1) { + Assertions.fail("Expected only one atom when querying for reified predicate!"); + } + return (ConstantTerm) reifiedPredicateResult.get(0).getTerms().get(0); + } + + private static AtomQuery queryForReifiedPredicate(Predicate predicate) { + return Atoms.query("predicate", 3) + .withTermEquals(1, Terms.newConstant(predicate.getName())) + .withTermEquals(2, Terms.newConstant(predicate.getArity())); + } + + private static Stream> ruleBodyLiteralIdStream(ConstantTerm ruleId, Set reifiedProgram) { + return reifiedProgram.stream() + .filter(Atoms.query("rule_bodyLiteral", 2).withTermEquals(0, ruleId)) + // After filtering we have atoms describing body literals - extract the second term which is the id of the literal + .map((bodyLiteralDescriptor) -> (ConstantTerm) bodyLiteralDescriptor.getTerms().get(1)); + } + } From d28c2d663ec9daec5310d6ecfde648e0857af4f9 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Tue, 20 Dec 2022 22:54:24 +0100 Subject: [PATCH 57/96] No longer use Strings to encode substitutions in body-representing literals. - RuleAtom now is 1-ary atom with Java-object based constant directly linking to non-ground rule and its grounding substitution. - DefaultSolver uses that RuleAtomConstant to get substitution for justification analysis - Removed Substitutions helper that provided (buggy) string-parsing to get encoded substitution. - Add RuleAtomTest and moved test for obtaining substitution over from SubstitutionTest. --- .../tuwien/kr/alpha/core/atoms/RuleAtom.java | 80 ++++++++++++++----- .../kr/alpha/core/solver/DefaultSolver.java | 53 ++++++------ .../kr/alpha/core/util/Substitutions.java | 31 ------- .../kr/alpha/core/atoms/RuleAtomTest.java | 50 ++++++++++++ .../alpha/core/grounder/SubstitutionTest.java | 25 ++---- 5 files changed, 141 insertions(+), 98 deletions(-) delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java create mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java index 605bc8dfb..4bc08f609 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java @@ -27,11 +27,6 @@ */ package at.ac.tuwien.kr.alpha.core.atoms; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Set; - import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -43,27 +38,74 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; + /** - * Atoms corresponding to rule bodies use this predicate, first term is rule number, - * second is a term containing variable substitutions. + * Atoms corresponding to rule bodies use this predicate, its only term is a Java object linking to the non-ground rule and grounding substitution. */ public class RuleAtom implements Atom { - public static final Predicate PREDICATE = Predicates.getPredicate("_R_", 2, true, true); + public static final Predicate PREDICATE = Predicates.getPredicate("_R_", 1, true, true); + + private final List> terms; + + public static class RuleAtomConstant implements Comparable { + private final CompiledRule nonGroundRule; + private final Substitution substitution; + private final Term[] compiledSubstitution; // For faster comparison to other RuleAtomConstants: ascending key-ordered right-hand sides of substitution. + private final int ruleId; + + RuleAtomConstant(CompiledRule nonGroundRule, Substitution substitution) { + this.nonGroundRule = nonGroundRule; + this.substitution = substitution; + ruleId = nonGroundRule.getRuleId(); + compiledSubstitution = new Term[this.substitution.getSubstitution().size()]; + int i = 0; + // Iterate substitution in ascending order of its key and flatten the tree into an array. + for (Map.Entry variableSubstitution : this.substitution.getSubstitution().entrySet()) { + this.compiledSubstitution[i++] = variableSubstitution.getValue(); + } + } - private final List> terms; + @Override + public int compareTo(RuleAtomConstant other) { + if (ruleId != other.ruleId) { + return Integer.compare(ruleId, other.ruleId); + } + // Note: We assume here that substitutions for the same nonGroundRule are all over the same variables. + if (compiledSubstitution.length != other.compiledSubstitution.length) { + throw oops("RuleAtoms over the same rule have different-sized substitutions."); + } + for (int i = 0; i < compiledSubstitution.length; i++) { + // Since all terms are interned, equality can be checked by comparing the Java-objects. + if (compiledSubstitution[i] != other.compiledSubstitution[i]) { + return compiledSubstitution[i].compareTo(other.compiledSubstitution[i]); + } + } + return 0; + } + + public CompiledRule getNonGroundRule() { + return nonGroundRule; + } - private RuleAtom(List> terms) { - if (terms.size() != 2) { - throw new IllegalArgumentException(); + public Substitution getSubstitution() { + return substitution; } - this.terms = terms; + @Override + public String toString() { + return "ruleId=" + ruleId + ":substitution=" + Arrays.toString(compiledSubstitution); + } } public RuleAtom(CompiledRule nonGroundRule, Substitution substitution) { - this(Arrays.asList( - Terms.newConstant(Integer.toString(nonGroundRule.getRuleId())), - Terms.newConstant(substitution.toString()))); + this.terms = Collections.singletonList(Terms.newConstant(new RuleAtomConstant(nonGroundRule, substitution))); } @Override @@ -73,12 +115,12 @@ public Predicate getPredicate() { @Override public List getTerms() { - return Arrays.asList(terms.get(0), terms.get(1)); + return Collections.singletonList(terms.get(0)); } @Override public boolean isGround() { - // NOTE: Both terms are ConstantTerms, which are ground by definition. + // NOTE: single term is a ConstantTerm, which is ground by definition. return true; } @@ -113,7 +155,7 @@ public int hashCode() { @Override public String toString() { - return PREDICATE.getName() + "(" + terms.get(0) + "," + terms.get(1) + ')'; + return PREDICATE.getName() + "(" + terms.get(0) + ')'; } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java index b6d952e23..9dd5e37cf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java @@ -27,28 +27,6 @@ */ package at.ac.tuwien.kr.alpha.core.solver; -import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; -import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToNegatedLiteral; -import static at.ac.tuwien.kr.alpha.core.solver.NoGoodStore.LBD_NO_VALUE; -import static at.ac.tuwien.kr.alpha.core.solver.heuristics.BranchingHeuristic.DEFAULT_CHOICE_LITERAL; -import static at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult.UNSAT; - -import java.util.ArrayList; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.LinkedList; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Random; -import java.util.Set; -import java.util.function.Consumer; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.StatisticsReportingSolver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; @@ -70,7 +48,27 @@ import at.ac.tuwien.kr.alpha.core.solver.heuristics.HeuristicsConfiguration; import at.ac.tuwien.kr.alpha.core.solver.heuristics.NaiveHeuristic; import at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner; -import at.ac.tuwien.kr.alpha.core.util.Substitutions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Random; +import java.util.Set; +import java.util.function.Consumer; + +import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; +import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomOf; +import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToLiteral; +import static at.ac.tuwien.kr.alpha.core.atoms.Literals.atomToNegatedLiteral; +import static at.ac.tuwien.kr.alpha.core.solver.NoGoodStore.LBD_NO_VALUE; +import static at.ac.tuwien.kr.alpha.core.solver.heuristics.BranchingHeuristic.DEFAULT_CHOICE_LITERAL; +import static at.ac.tuwien.kr.alpha.core.solver.learning.GroundConflictNoGoodLearner.ConflictAnalysisResult.UNSAT; /** * The new default solver employed in Alpha. @@ -378,11 +376,10 @@ private boolean treatConflictAfterClosing(Antecedent violatedNoGood) { continue; } // For RuleAtoms in toJustify the corresponding ground body contains BasicAtoms that have been assigned FALSE in the closing. - // First, translate RuleAtom back to NonGroundRule + Substitution. - String ruleId = (String) ((ConstantTerm)atom.getTerms().get(0)).getObject(); - CompiledRule nonGroundRule = analyzingGrounder.getNonGroundRule(Integer.parseInt(ruleId)); - String substitution = (String) ((ConstantTerm)atom.getTerms().get(1)).getObject(); - Substitution groundingSubstitution = Substitutions.fromString(substitution); + // First, get NonGroundRule + Substitution, stored in the RuleAtom's single term. + RuleAtom.RuleAtomConstant ruleAtomConstant = (RuleAtom.RuleAtomConstant) ((ConstantTerm)(atom.getTerms().get(0))).getObject(); + Substitution groundingSubstitution = ruleAtomConstant.getSubstitution(); + CompiledRule nonGroundRule = ruleAtomConstant.getNonGroundRule(); // Find ground literals in the body that have been assigned false and justify those. for (Literal bodyLiteral : nonGroundRule.getBody()) { Atom groundAtom = bodyLiteral.getAtom().substitute(groundingSubstitution); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java deleted file mode 100644 index 40470cf09..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/util/Substitutions.java +++ /dev/null @@ -1,31 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.util; - -import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.parser.ProgramPartParser; - -public final class Substitutions { - - private static final ProgramPartParser PROGRAM_PART_PARSER = new ProgramPartParser(); - - private Substitutions() { - throw new AssertionError("Cannot instantiate utility class!"); - } - - public static Substitution fromString(String str) { - String bare = str.substring(1, str.length() - 1); - String[] assignments = bare.split(","); - BasicSubstitution ret = new BasicSubstitution(); - for (String assignment : assignments) { - String[] keyVal = assignment.split("->"); - VariableTerm variable = Terms.newVariable(keyVal[0]); - Term assignedTerm = PROGRAM_PART_PARSER.parseTerm(keyVal[1]); - ret.put(variable, assignedTerm); - } - return ret; - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java new file mode 100644 index 000000000..fc29f880e --- /dev/null +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java @@ -0,0 +1,50 @@ +package at.ac.tuwien.kr.alpha.core.atoms; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.rules.Rule; +import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; +import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * Copyright (c) 2022, the Alpha Team. + */ +public class RuleAtomTest { + private static final ProgramParser PARSER = new ProgramParserImpl(); + + private static final VariableTerm X = Terms.newVariable("X"); + private static final VariableTerm Y = Terms.newVariable("Y"); + private static final Predicate PREDICATE = Predicates.getPredicate("p", 1); + private static final BasicAtom PX = Atoms.newBasicAtom(PREDICATE, X); + private static final BasicAtom PY = Atoms.newBasicAtom(PREDICATE, Y); + + @Test + public void substitutionObtainableFromRuleAtom() { + Rule rule = PARSER.parse("q(X) :- p(X,Y).").getRules().get(0); + CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); + // Build substitution X -> a, Y -> b. + Substitution substitution = BasicSubstitution.specializeSubstitution( + PY, new Instance(Terms.newSymbolicConstant("b")), BasicSubstitution.specializeSubstitution( + PX, new Instance(Terms.newSymbolicConstant("a")), BasicSubstitution.EMPTY_SUBSTITUTION)); + + RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); + RuleAtom.RuleAtomConstant substitutionFromRuleAtom = (RuleAtom.RuleAtomConstant) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); + assertEquals(substitution, substitutionFromRuleAtom.getSubstitution()); + } + +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java index 2fc8f87a2..cad7db103 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/SubstitutionTest.java @@ -27,12 +27,6 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.Arrays; - -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; @@ -50,13 +44,16 @@ import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.atoms.RuleAtom; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.rules.NormalRuleImpl; import at.ac.tuwien.kr.alpha.core.test.util.SubstitutionTestUtil; -import at.ac.tuwien.kr.alpha.core.util.Substitutions; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class SubstitutionTest { private static final ProgramParser PARSER = new ProgramParserImpl(); @@ -165,16 +162,4 @@ private void groundLiteralToString(boolean negated) { String printedString = SubstitutionTestUtil.groundLiteralToString(atom.toLiteral(!negated), substitution, true); assertEquals((negated ? "not " : "") + "p(a, b)", printedString); } - - @Test - public void substitutionFromString() { - Rule rule = PARSER.parse("x :- p(X,Y), not q(X,Y).").getRules().get(0); - CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); - Substitution substitution1 = BasicSubstitution.specializeSubstitution(PX, PA, BasicSubstitution.EMPTY_SUBSTITUTION); - Substitution substitution = BasicSubstitution.specializeSubstitution(PY, PB, substitution1); - RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); - String substitutionString = (String) ((ConstantTerm) ruleAtom.getTerms().get(1)).getObject(); - Substitution fromString = Substitutions.fromString(substitutionString); - assertEquals(substitution, fromString); - } } From b16072e6ca29c28c3748d68bd3d2ec872a8e6d77 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Mon, 2 Jan 2023 04:52:17 +0100 Subject: [PATCH 58/96] Add equals() and hashCode() to InternalRule and RuleAtomConstant. --- .../tuwien/kr/alpha/core/atoms/RuleAtom.java | 56 ++++++++++++------- .../kr/alpha/core/rules/InternalRule.java | 33 +++++++++-- 2 files changed, 65 insertions(+), 24 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java index 4bc08f609..827a91a91 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java @@ -38,8 +38,8 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; -import java.util.Arrays; import java.util.Collections; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; @@ -57,34 +57,31 @@ public class RuleAtom implements Atom { public static class RuleAtomConstant implements Comparable { private final CompiledRule nonGroundRule; private final Substitution substitution; - private final Term[] compiledSubstitution; // For faster comparison to other RuleAtomConstants: ascending key-ordered right-hand sides of substitution. - private final int ruleId; + private final int substitutionHash; RuleAtomConstant(CompiledRule nonGroundRule, Substitution substitution) { this.nonGroundRule = nonGroundRule; this.substitution = substitution; - ruleId = nonGroundRule.getRuleId(); - compiledSubstitution = new Term[this.substitution.getSubstitution().size()]; - int i = 0; - // Iterate substitution in ascending order of its key and flatten the tree into an array. - for (Map.Entry variableSubstitution : this.substitution.getSubstitution().entrySet()) { - this.compiledSubstitution[i++] = variableSubstitution.getValue(); - } + this.substitutionHash = substitution.hashCode(); } @Override public int compareTo(RuleAtomConstant other) { - if (ruleId != other.ruleId) { - return Integer.compare(ruleId, other.ruleId); + if (nonGroundRule.getRuleId() != other.nonGroundRule.getRuleId()) { + return Integer.compare(nonGroundRule.getRuleId(), other.nonGroundRule.getRuleId()); } - // Note: We assume here that substitutions for the same nonGroundRule are all over the same variables. - if (compiledSubstitution.length != other.compiledSubstitution.length) { + if (substitution.getSubstitution().size() != other.getSubstitution().getSubstitution().size()) { throw oops("RuleAtoms over the same rule have different-sized substitutions."); } - for (int i = 0; i < compiledSubstitution.length; i++) { - // Since all terms are interned, equality can be checked by comparing the Java-objects. - if (compiledSubstitution[i] != other.compiledSubstitution[i]) { - return compiledSubstitution[i].compareTo(other.compiledSubstitution[i]); + // Note: We assume here that substitutions for the same nonGroundRule are all over the same variables and iteration order. + Iterator> iteratorThis = substitution.getSubstitution().entrySet().iterator(); + Iterator> iteratorOther = other.getSubstitution().getSubstitution().entrySet().iterator(); + while (iteratorThis.hasNext()) { + Term thisTerm = iteratorThis.next().getValue(); + Term otherTerm = iteratorOther.next().getValue(); + int compare = thisTerm.compareTo(otherTerm); + if (compare != 0) { + return compare; } } return 0; @@ -98,9 +95,30 @@ public Substitution getSubstitution() { return substitution; } + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + RuleAtomConstant that = (RuleAtomConstant) o; + if (!nonGroundRule.equals(that.nonGroundRule) || substitutionHash != that.substitutionHash) { + return false; + } + return getSubstitution().equals(that.getSubstitution()); + } + + @Override + public int hashCode() { + return 31 * getNonGroundRule().hashCode() + substitutionHash; + } + @Override public String toString() { - return "ruleId=" + ruleId + ":substitution=" + Arrays.toString(compiledSubstitution); + return "ruleId=" + nonGroundRule.getRuleId() + ":substitution=" + substitution.toString(); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java index 9a72fca12..c9148acf4 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/InternalRule.java @@ -27,11 +27,6 @@ */ package at.ac.tuwien.kr.alpha.core.rules; -import java.util.ArrayList; -import java.util.List; - -import com.google.common.annotations.VisibleForTesting; - import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; @@ -44,10 +39,16 @@ import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; +import com.google.common.annotations.VisibleForTesting; + +import java.util.ArrayList; +import java.util.List; /** * Represents a normal rule or a constraint for the semi-naive grounder. * A normal rule has no head atom if it represents a constraint, otherwise it has one atom in its head. + * + * {@link InternalRule}s are assumed to be uniquely identified by an ID. */ public class InternalRule extends NormalRuleImpl implements CompiledRule { @@ -59,6 +60,12 @@ public class InternalRule extends NormalRuleImpl implements CompiledRule { private final RuleGroundingInfoImpl groundingOrders; + /** + * Creates a new {@link InternalRule} with the given head plus body and a fresh identifier. + * Note that no check is done whether head and body already occur in another {@link InternalRule}. + * @param head the head of the rule. + * @param body the list of body literals of the rule. + */ public InternalRule(NormalHead head, List body) { super(head, body); if (body.isEmpty()) { @@ -143,4 +150,20 @@ public int getRuleId() { return this.ruleId; } + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + InternalRule that = (InternalRule) o; + return getRuleId() == that.getRuleId(); + } + + @Override + public int hashCode() { + return Integer.hashCode(getRuleId()); + } } From c1e8afcac2188aca8de6e5ab7e92c430214f4bbb Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 2 Jan 2023 19:06:20 +0100 Subject: [PATCH 59/96] Issue 350: Upgrade Gradle to 7.6 --- build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle.kts b/build.gradle.kts index bd335656d..7268473b8 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -5,6 +5,6 @@ plugins { } tasks.wrapper { - gradleVersion = "7.3.2" + gradleVersion = "7.6" distributionType = Wrapper.DistributionType.ALL } From 28599b1591d3773302588d5d267aadc6c0a3be6a Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 2 Jan 2023 19:45:09 +0100 Subject: [PATCH 60/96] Issue 350: Upgrade Gradle version to 3.6 --- gradle/wrapper/gradle-wrapper.properties | 2 +- gradlew | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index ac0b842f1..f42e62f37 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.2-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-all.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew index 1b6c78733..c53aefaa5 100755 --- a/gradlew +++ b/gradlew @@ -1,7 +1,7 @@ #!/bin/sh # -# Copyright © 2015-2021 the original authors. +# Copyright © 2015-2021 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -32,10 +32,10 @@ # Busybox and similar reduced shells will NOT work, because this script # requires all of these POSIX shell features: # * functions; -# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», -# «${var#prefix}», «${var%suffix}», and «$( cmd )»; -# * compound commands having a testable exit status, especially «case»; -# * various built-in commands including «command», «set», and «ulimit». +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». # # Important for patching: # From e7877ea88bb5f76959a120384cc6fb090d5c3f00 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Tue, 3 Jan 2023 14:47:45 +0100 Subject: [PATCH 61/96] Add test for recovering substitution with function terms from body-representing atom. --- .../kr/alpha/core/atoms/RuleAtomTest.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java index fc29f880e..8f2af7dd5 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java @@ -47,4 +47,22 @@ PY, new Instance(Terms.newSymbolicConstant("b")), BasicSubstitution.specializeSu assertEquals(substitution, substitutionFromRuleAtom.getSubstitution()); } + @Test + public void substitutionWithFunctionTermsObtainableFromRuleAtom() { + Rule rule = PARSER.parse("q(X) :- p(X,Y).").getRules().get(0); + CompiledRule nonGroundRule = InternalRule.fromNormalRule(NormalRuleImpl.fromBasicRule(rule)); + // Build substitution X -> b(a,a), Y -> b(b(a,a),b(a,a)). + BasicAtom atomForSpecialize = Atoms.newBasicAtom(Predicates.getPredicate("p", 2), X, Y); + ConstantTerm aTerm = Terms.newSymbolicConstant("a"); + Instance instanceForSpecialize = new Instance(Terms.newFunctionTerm("b", aTerm, aTerm), + Terms.newFunctionTerm("b", + Terms.newFunctionTerm("b", aTerm, aTerm), + Terms.newFunctionTerm("b", aTerm, aTerm))); + Substitution substitution = BasicSubstitution.specializeSubstitution( + atomForSpecialize, instanceForSpecialize, BasicSubstitution.EMPTY_SUBSTITUTION); + + RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); + RuleAtom.RuleAtomConstant substitutionFromRuleAtom = (RuleAtom.RuleAtomConstant) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); + assertEquals(substitution, substitutionFromRuleAtom.getSubstitution()); + } } \ No newline at end of file From 5c93f91360bdd90c2ed22f9c09afb42174e151dd Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Tue, 3 Jan 2023 15:33:20 +0100 Subject: [PATCH 62/96] Rename RuleAtomConstant to RuleAtomData. --- .../at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java | 12 ++++++------ .../tuwien/kr/alpha/core/solver/DefaultSolver.java | 6 +++--- .../ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java | 4 ++-- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java index 827a91a91..caeea5d27 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java @@ -52,21 +52,21 @@ public class RuleAtom implements Atom { public static final Predicate PREDICATE = Predicates.getPredicate("_R_", 1, true, true); - private final List> terms; + private final List> terms; - public static class RuleAtomConstant implements Comparable { + public static class RuleAtomData implements Comparable { private final CompiledRule nonGroundRule; private final Substitution substitution; private final int substitutionHash; - RuleAtomConstant(CompiledRule nonGroundRule, Substitution substitution) { + RuleAtomData(CompiledRule nonGroundRule, Substitution substitution) { this.nonGroundRule = nonGroundRule; this.substitution = substitution; this.substitutionHash = substitution.hashCode(); } @Override - public int compareTo(RuleAtomConstant other) { + public int compareTo(RuleAtomData other) { if (nonGroundRule.getRuleId() != other.nonGroundRule.getRuleId()) { return Integer.compare(nonGroundRule.getRuleId(), other.nonGroundRule.getRuleId()); } @@ -104,7 +104,7 @@ public boolean equals(Object o) { return false; } - RuleAtomConstant that = (RuleAtomConstant) o; + RuleAtomData that = (RuleAtomData) o; if (!nonGroundRule.equals(that.nonGroundRule) || substitutionHash != that.substitutionHash) { return false; } @@ -123,7 +123,7 @@ public String toString() { } public RuleAtom(CompiledRule nonGroundRule, Substitution substitution) { - this.terms = Collections.singletonList(Terms.newConstant(new RuleAtomConstant(nonGroundRule, substitution))); + this.terms = Collections.singletonList(Terms.newConstant(new RuleAtomData(nonGroundRule, substitution))); } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java index 9dd5e37cf..32bba3b67 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/DefaultSolver.java @@ -377,9 +377,9 @@ private boolean treatConflictAfterClosing(Antecedent violatedNoGood) { } // For RuleAtoms in toJustify the corresponding ground body contains BasicAtoms that have been assigned FALSE in the closing. // First, get NonGroundRule + Substitution, stored in the RuleAtom's single term. - RuleAtom.RuleAtomConstant ruleAtomConstant = (RuleAtom.RuleAtomConstant) ((ConstantTerm)(atom.getTerms().get(0))).getObject(); - Substitution groundingSubstitution = ruleAtomConstant.getSubstitution(); - CompiledRule nonGroundRule = ruleAtomConstant.getNonGroundRule(); + RuleAtom.RuleAtomData ruleAtomData = (RuleAtom.RuleAtomData) ((ConstantTerm)(atom.getTerms().get(0))).getObject(); + Substitution groundingSubstitution = ruleAtomData.getSubstitution(); + CompiledRule nonGroundRule = ruleAtomData.getNonGroundRule(); // Find ground literals in the body that have been assigned false and justify those. for (Literal bodyLiteral : nonGroundRule.getBody()) { Atom groundAtom = bodyLiteral.getAtom().substitute(groundingSubstitution); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java index 8f2af7dd5..1638d036e 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtomTest.java @@ -43,7 +43,7 @@ PY, new Instance(Terms.newSymbolicConstant("b")), BasicSubstitution.specializeSu PX, new Instance(Terms.newSymbolicConstant("a")), BasicSubstitution.EMPTY_SUBSTITUTION)); RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); - RuleAtom.RuleAtomConstant substitutionFromRuleAtom = (RuleAtom.RuleAtomConstant) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); + RuleAtom.RuleAtomData substitutionFromRuleAtom = (RuleAtom.RuleAtomData) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); assertEquals(substitution, substitutionFromRuleAtom.getSubstitution()); } @@ -62,7 +62,7 @@ public void substitutionWithFunctionTermsObtainableFromRuleAtom() { atomForSpecialize, instanceForSpecialize, BasicSubstitution.EMPTY_SUBSTITUTION); RuleAtom ruleAtom = new RuleAtom(nonGroundRule, substitution); - RuleAtom.RuleAtomConstant substitutionFromRuleAtom = (RuleAtom.RuleAtomConstant) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); + RuleAtom.RuleAtomData substitutionFromRuleAtom = (RuleAtom.RuleAtomData) ((ConstantTerm) ruleAtom.getTerms().get(0)).getObject(); assertEquals(substitution, substitutionFromRuleAtom.getSubstitution()); } } \ No newline at end of file From 55ee779ec82c26126ec62b5588c92ee8efe66790 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Wed, 4 Jan 2023 04:19:54 +0100 Subject: [PATCH 63/96] Check for inconsistent substitutions when comparing RuleAtomData. --- .../at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java index caeea5d27..a3fef5546 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/atoms/RuleAtom.java @@ -73,13 +73,18 @@ public int compareTo(RuleAtomData other) { if (substitution.getSubstitution().size() != other.getSubstitution().getSubstitution().size()) { throw oops("RuleAtoms over the same rule have different-sized substitutions."); } - // Note: We assume here that substitutions for the same nonGroundRule are all over the same variables and iteration order. + // Note: Since Substitutions are backed by TreeMaps, their variables can be iterated in the same order. Iterator> iteratorThis = substitution.getSubstitution().entrySet().iterator(); Iterator> iteratorOther = other.getSubstitution().getSubstitution().entrySet().iterator(); while (iteratorThis.hasNext()) { - Term thisTerm = iteratorThis.next().getValue(); - Term otherTerm = iteratorOther.next().getValue(); - int compare = thisTerm.compareTo(otherTerm); + Map.Entry thisNextEntry = iteratorThis.next(); + Map.Entry otherNextEntry = iteratorOther.next(); + VariableTerm thisVariable = thisNextEntry.getKey(); + VariableTerm otherVariable = otherNextEntry.getKey(); + if (thisVariable != otherVariable) { + throw oops("Comparing substitutions for the same non-ground rule whose variables differ: " + thisVariable + " != " + otherVariable); + } + int compare = thisNextEntry.getValue().compareTo(otherNextEntry.getValue()); if (compare != 0) { return compare; } From e41c0d8ea32dd1e08b38ce5ecfaf35e69352a174 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Wed, 4 Jan 2023 04:37:00 +0100 Subject: [PATCH 64/96] Small polish in BasicSubstitution as suggested by Michael Langowski. --- .../commons/substitutions/BasicSubstitution.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java index df8d26d6a..dfb4d3599 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/substitutions/BasicSubstitution.java @@ -27,12 +27,6 @@ */ package at.ac.tuwien.kr.alpha.commons.substitutions; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Set; -import java.util.TreeMap; - import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -42,6 +36,12 @@ import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.util.Util; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.TreeMap; + public class BasicSubstitution implements at.ac.tuwien.kr.alpha.api.grounder.Substitution { public static final Substitution EMPTY_SUBSTITUTION = new BasicSubstitution() { @@ -193,7 +193,7 @@ public boolean isEmpty() { @Override public boolean isVariableSet(VariableTerm variable) { - return substitution.get(variable) != null; + return substitution.containsKey(variable); } public Set getMappedVariables() { From 104b724fbad31a2be3776800a3a4eb86a2cede7d Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 5 Jan 2023 18:42:41 +0100 Subject: [PATCH 65/96] reification test for aggregate and external atoms --- .../kr/alpha/api/impl/ReificationTest.java | 87 ++++++++++++++----- 1 file changed, 64 insertions(+), 23 deletions(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java index 997a29a2b..cc492106e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -55,18 +55,14 @@ public void propositionalFact() { assertEquals(1, factAtomResult.size()); BasicAtom factAtom = factAtomResult.get(0); Term idTerm = factAtom.getTerms().get(0); - assertTrue(reified.stream().filter( + assertTrue(reified.stream().anyMatch( Atoms.query("atom_type", 2) .withTermEquals(0, idTerm) - .withTermEquals(1, Terms.newSymbolicConstant("basic"))) - .findFirst() - .isPresent()); - assertTrue(reified.stream().filter( + .withTermEquals(1, Terms.newSymbolicConstant("basic")))); + assertTrue(reified.stream().anyMatch( Atoms.query("basicAtom_numTerms", 2) .withTermEquals(0, idTerm) - .withTermEquals(1, Terms.newConstant(0))) - .findFirst() - .isPresent()); + .withTermEquals(1, Terms.newConstant(0)))); Optional predicateAtomResult = reified.stream().filter(Atoms.query("basicAtom_predicate", 2) .withTermEquals(0, idTerm)).findFirst(); assertTrue(predicateAtomResult.isPresent()); @@ -98,7 +94,7 @@ public void positiveRule() { Atoms.query("head_type", 2) .withTermEquals(0, headId) .withTermEquals(1, Terms.newSymbolicConstant("normal"))) - .collect(Collectors.toList()).size()); + .count()); List headAtomDescriptorResult = reified.stream().filter( Atoms.query("normalHead_atom", 2) .withTermEquals(0, headId)) @@ -117,7 +113,7 @@ public void positiveRule() { Atoms.query("rule_numBodyLiterals", 2) .withTermEquals(0, ruleId) .withTermEquals(1, Terms.newConstant(2))) - .collect(Collectors.toList()).size()); + .count()); Set bodyLiteralDescriptors = reified.stream().filter( Atoms.query("rule_bodyLiteral", 2) .withTermEquals(0, ruleId)) @@ -128,20 +124,20 @@ public void positiveRule() { Atoms.query("literal_polarity", 2) .withTermEquals(0, bodyLiteralDescriptor.getTerms().get(1)) .withTermEquals(1, Terms.newSymbolicConstant("pos"))) - .collect(Collectors.toList()).size()); + .count()); assertEquals(1, reified.stream().filter( Atoms.query("literal_atom", 2) .withTermEquals(0, bodyLiteralDescriptor.getTerms().get(1))) - .collect(Collectors.toList()).size()); + .count()); } assertEquals(3, reified.stream().filter( Atoms.query("term_type", 2) .withTermEquals(1, Terms.newSymbolicConstant("variable"))) - .collect(Collectors.toSet()).size()); + .count()); assertEquals(3, reified.stream().filter( Atoms.query("variableTerm_symbol", 2) .withTermEquals(1, Terms.newConstant("X"))) - .collect(Collectors.toSet()).size()); + .count()); } @Test @@ -155,8 +151,7 @@ public void ruleWithNegativeLiteral() { Atoms.query("literal_polarity", 2) .withTermEquals(0, qIds.get(0)) .withTermEquals(1, Terms.newSymbolicConstant("pos"))) - .collect(Collectors.toList()) - .size()); + .count()); List> rIds = findLiteralIdsForPredicate(Predicates.getPredicate("r", 1), Terms.newConstant(0), reified); assertEquals(1, rIds.size()); @@ -165,8 +160,7 @@ public void ruleWithNegativeLiteral() { Atoms.query("literal_polarity", 2) .withTermEquals(0, rIds.get(0)) .withTermEquals(1, Terms.newSymbolicConstant("neg"))) - .collect(Collectors.toList()) - .size()); + .count()); } @Test @@ -178,7 +172,16 @@ public void comparisonAtom() { @Test public void aggregateAtom() { - + Set reified = alpha.reify(alpha.readProgramString("aggregateTrue :- X < #count{X : p(X)} < Y, X = 1, Y = 3.")); + List> countLitIds = findLiteralIdsForAggregate(Terms.newSymbolicConstant("count"), Terms.newConstant(0), reified); + assertEquals(1, countLitIds.size()); + } + + @Test + public void externalAtom() { + Set reified = alpha.reify(alpha.readProgramString("foo :- &stdlib_string_concat[\"foo\", \"bar\"](FOOBAR).")); + List> strcatLitIds = findLiteralIdsForExternal(Terms.newConstant("stdlib_string_concat"), Terms.newConstant(0), reified); + assertEquals(1, strcatLitIds.size()); } private static List> findLiteralIdsForPredicate(Predicate predicate, ConstantTerm reifiedRuleId, @@ -206,6 +209,46 @@ private static List> findLiteralIdsForPredicate(Predicate predic .collect(Collectors.toList()); } + private static List> findLiteralIdsForAggregate(ConstantTerm aggregateFunction, ConstantTerm reifiedRuleId, Set reifiedProgram) { + return ruleBodyLiteralIdStream(reifiedRuleId, reifiedProgram) + .filter((literalId) -> { + List> atomIdResult = reifiedProgram.stream() + .filter(Atoms.query("literal_atom", 2).withTermEquals(0, literalId)) + .map((literalToAtomDescriptor) -> (ConstantTerm) literalToAtomDescriptor.getTerms() + .get(1)) + .collect(Collectors.toList()); + if (atomIdResult.isEmpty()) { + return false; + } + ConstantTerm atomId = atomIdResult.get(0); + return reifiedProgram.stream() + .anyMatch( + Atoms.query("aggregateAtom_aggregateFunction", 2) + .withTermEquals(0, atomId) + .withTermEquals(1, aggregateFunction)); + }).collect(Collectors.toList()); + } + + private static List> findLiteralIdsForExternal(ConstantTerm methodName, ConstantTerm reifiedRuleId, Set reifiedProgram) { + return ruleBodyLiteralIdStream(reifiedRuleId, reifiedProgram) + .filter((literalId) -> { + List> atomIdResult = reifiedProgram.stream() + .filter(Atoms.query("literal_atom", 2).withTermEquals(0, literalId)) + .map((literalToAtomDescriptor) -> (ConstantTerm) literalToAtomDescriptor.getTerms() + .get(1)) + .collect(Collectors.toList()); + if (atomIdResult.isEmpty()) { + return false; + } + ConstantTerm atomId = atomIdResult.get(0); + return reifiedProgram.stream() + .anyMatch( + Atoms.query("externalAtom_name", 2) + .withTermEquals(0, atomId) + .withTermEquals(1, methodName)); + }).collect(Collectors.toList()); + } + private static List> findLiteralIdsForComparisonOperator(ComparisonOperator operator, ConstantTerm reifiedRuleId, Set reifiedProgram) { return ruleBodyLiteralIdStream(reifiedRuleId, reifiedProgram) @@ -220,12 +263,10 @@ private static List> findLiteralIdsForComparisonOperator(Compari } ConstantTerm atomId = atomIdResult.get(0); return reifiedProgram.stream() - .filter( + .anyMatch( Atoms.query("comparisonAtom_operator", 2) .withTermEquals(0, atomId) - .withTermEquals(1, CMP_OP_IDS.get(operator))) - .findAny() - .isPresent(); + .withTermEquals(1, CMP_OP_IDS.get(operator))); }).collect(Collectors.toList()); } From 9a43dffc8d1747ebe4e4ca072ec9b9bc6d1e450e Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 5 Jan 2023 19:10:28 +0100 Subject: [PATCH 66/96] Update alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java Co-authored-by: Antonius Weinzierl --- .../tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java index 9dfbde0f0..7ba031a80 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/AtomQueryImpl.java @@ -38,7 +38,7 @@ static AtomQuery forPredicate(Predicate predicate) { } static AtomQuery forPredicate(String name, int arity) { - return new AtomQueryImpl(Predicates.getPredicate(name, arity)); + return forPredicate(Predicates.getPredicate(name, arity)); } /** From ce69537f35c869018915378f9d4770d2e0a68b43 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 5 Jan 2023 20:03:30 +0100 Subject: [PATCH 67/96] java version to 11 instead of 17, set jvm target to 11 kotlin --- .github/workflows/build.yml | 4 +++- buildSrc/build.gradle.kts | 5 +++++ .../src/main/kotlin/alpha.java-common-conventions.gradle.kts | 4 ++-- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 90e393fa2..ce2cc917e 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,6 +12,8 @@ jobs: # OR # - not succeeded by any other release java: + # LTS and in "Premier Support" as of 2019-03 (until 2023-09) + - 11 # LTS as of 2021-12 (until 2029) - 17 os: [ubuntu, windows] @@ -19,7 +21,7 @@ jobs: # We only post coverage data for exactly one build to coveralls. # To pick that build from the build matrix, we designate one # Java version to be the "main" one. - MAIN_JAVA: 17 + MAIN_JAVA: 11 # We only post coverage data for exactly one build to coveralls. # To pick that build from the build matrix, we designate one # OS to be the "main" one. diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts index c1b2ed676..f12104bb8 100644 --- a/buildSrc/build.gradle.kts +++ b/buildSrc/build.gradle.kts @@ -2,6 +2,11 @@ plugins { `kotlin-dsl` } +tasks.withType().configureEach { + kotlinOptions { + jvmTarget = "11" + } +} repositories { mavenCentral { metadataSources { mavenPom() } } } diff --git a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts index 37cd44dca..0735c42a8 100644 --- a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts @@ -12,8 +12,8 @@ repositories { mavenCentral { metadataSources { mavenPom() } } } -java.sourceCompatibility = JavaVersion.VERSION_17 -java.targetCompatibility = JavaVersion.VERSION_17 +java.sourceCompatibility = JavaVersion.VERSION_11 +java.targetCompatibility = JavaVersion.VERSION_11 dependencies { implementation("org.apache.commons:commons-collections4:4.4") From acf0e940c5eff94c6d00868ae3aaec3240e95aba Mon Sep 17 00:00:00 2001 From: Lorenz Leutgeb Date: Tue, 10 Jan 2023 15:20:51 +0100 Subject: [PATCH 68/96] ci: Upgrade actions/setup-java To work around deprecation of `set-output`, see also https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/ --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 702e71d81..51af8b93a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -40,7 +40,7 @@ jobs: # See https://github.com/marketplace/actions/gradle-wrapper-validation - uses: gradle/wrapper-validation-action@v1 # See https://github.com/marketplace/actions/setup-java-jdk - - uses: actions/setup-java@v2 + - uses: actions/setup-java@v3 with: java-version: ${{ matrix.java }} distribution: 'temurin' From 28ab2bba121a1af420b89a8b983fed439308783b Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 12 Jan 2023 20:13:37 +0100 Subject: [PATCH 69/96] also reify constraints --- .../alpha/commons/programs/reification/Reifier.java | 12 +++++++----- .../ac/tuwien/kr/alpha/api/impl/ReificationTest.java | 7 +++++++ 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java index 040e1be4a..dba92f359 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java @@ -39,6 +39,7 @@ public class Reifier { // Predicates describing rules. static final Predicate RULE = Predicates.getPredicate("rule", 1); + static final Predicate CONSTRAINT = Predicates.getPredicate("constraint", 1); static final Predicate RULE_HEAD = Predicates.getPredicate("rule_head", 2); static final Predicate RULE_NUM_BODY_LITERALS = Predicates.getPredicate("rule_numBodyLiterals", 2); static final Predicate RULE_BODY_LITERAL = Predicates.getPredicate("rule_bodyLiteral", 2); @@ -201,9 +202,6 @@ public Set reifyProgram(ASPCore2Program program) { reifyAtom(ctx, factId, fact); } for (Rule rule : program.getRules()) { - if (rule.isConstraint()) { - continue; - } reifyRule(ctx, rule); } return ctx.computeReifiedProgram(); @@ -220,8 +218,12 @@ void reifyDirectives(ReificationContext ctx, InlineDirectives directives) { void reifyRule(ReificationContext ctx, Rule rule) { ConstantTerm ruleId = ctx.getNextId(); - ctx.addAtom(Atoms.newBasicAtom(RULE, ruleId)); - reifyHead(ctx, ruleId, rule.getHead()); + if (rule.isConstraint()) { + ctx.addAtom(Atoms.newBasicAtom(CONSTRAINT, ruleId)); + } else { + ctx.addAtom(Atoms.newBasicAtom(RULE, ruleId)); + reifyHead(ctx, ruleId, rule.getHead()); + } ctx.addAtom(Atoms.newBasicAtom(RULE_NUM_BODY_LITERALS, ruleId, Terms.newConstant(rule.getBody().size()))); for (Literal lit : rule.getBody()) { ConstantTerm literalId = ctx.getNextId(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java index cc492106e..4ec2ea622 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -184,6 +184,13 @@ public void externalAtom() { assertEquals(1, strcatLitIds.size()); } + @Test + public void constraint() { + Set reified = alpha.reify(alpha.readProgramString(":- p(X), q(X).")); + assertEquals(1, reified.stream().filter(Atoms.query("constraint", 1)).count()); + assertTrue(reified.stream().noneMatch(Atoms.query("rule", 1))); + } + private static List> findLiteralIdsForPredicate(Predicate predicate, ConstantTerm reifiedRuleId, Set reifiedProgram) { ConstantTerm predicateId = findPredicateId(predicate, reifiedProgram); From b16b9d6b044ffb9c799fdb3ad05441665cf93ce2 Mon Sep 17 00:00:00 2001 From: Antonius Weinzierl Date: Tue, 24 Jan 2023 10:29:27 +0100 Subject: [PATCH 70/96] Add JaCoCo report aggregation (#356) --- .github/workflows/build.yml | 2 +- build.gradle.kts | 18 +++++++++++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 51af8b93a..6e9b76d03 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -52,7 +52,7 @@ jobs: if: matrix.os == env.MAIN_OS && matrix.java == env.MAIN_JAVA continue-on-error: true with: - arguments: jacocoTestReport coveralls + arguments: jacocoAggregatedTestReport coveralls env: COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }} - uses: codecov/codecov-action@v1 diff --git a/build.gradle.kts b/build.gradle.kts index 7268473b8..9ada3d89e 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,10 +1,26 @@ plugins { jacoco - id("com.github.kt3k.coveralls") version "2.12.0" + id("jacoco-report-aggregation") } tasks.wrapper { gradleVersion = "7.6" distributionType = Wrapper.DistributionType.ALL } + +dependencies { + jacocoAggregation(project(":alpha-cli-app")) +} + +reporting { + reports { + val jacocoAggregatedTestReport by creating(JacocoCoverageReport::class) { + testType.set(TestSuiteType.UNIT_TEST) + } + } +} + +repositories { + mavenCentral { metadataSources { mavenPom() } } +} \ No newline at end of file From e049fbfe2cd2e31df77c2cc053b8d0a19dfe1d15 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 19 Feb 2023 21:52:17 +0100 Subject: [PATCH 71/96] unit tests: grammar + parser skeleton --- .../alpha/api/programs/tests/Assertion.java | 16 +++++++ .../kr/alpha/api/programs/tests/TestCase.java | 18 ++++++++ .../commons/programs/tests/AssertionImpl.java | 26 +++++++++++ .../commons/programs/tests/TestCaseImpl.java | 44 +++++++++++++++++++ .../alpha/commons/programs/tests/Tests.java | 25 +++++++++++ .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 20 +++++++-- .../alpha/core/parser/ParseTreeVisitor.java | 36 ++++++++++++--- 7 files changed, 177 insertions(+), 8 deletions(-) create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java new file mode 100644 index 000000000..3638603f4 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java @@ -0,0 +1,16 @@ +package at.ac.tuwien.kr.alpha.api.programs.tests; + +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; + +public interface Assertion { + + enum Mode { + FOR_ALL, + FOR_SOME; + } + + Mode getMode(); + + ASPCore2Program getVerifier(); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java new file mode 100644 index 000000000..df5c5e82f --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java @@ -0,0 +1,18 @@ +package at.ac.tuwien.kr.alpha.api.programs.tests; + +import java.util.Set; +import java.util.function.IntPredicate; + +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; + +public interface TestCase { + + String getName(); + + IntPredicate getAnswerSetCountVerifier(); + + Set getInput(); + + Set getAssertions(); + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java new file mode 100644 index 000000000..36bf901d2 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java @@ -0,0 +1,26 @@ +package at.ac.tuwien.kr.alpha.commons.programs.tests; + +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; + +class AssertionImpl implements Assertion { + + private final Mode mode; + private final ASPCore2Program verifier; + + AssertionImpl(final Mode mode, final ASPCore2Program verifier) { + this.mode = mode; + this.verifier = verifier; + } + + @Override + public Mode getMode() { + return mode; + } + + @Override + public ASPCore2Program getVerifier() { + return verifier; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java new file mode 100644 index 000000000..8b62dafd5 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java @@ -0,0 +1,44 @@ +package at.ac.tuwien.kr.alpha.commons.programs.tests; + +import java.util.Set; +import java.util.function.IntPredicate; + +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; + +class TestCaseImpl implements TestCase { + + private final String name; + private final IntPredicate answerSetCountVerifier; + private final Set input; + private final Set assertions; + + TestCaseImpl(final String name, final IntPredicate answerSetCountVerifier, final Set input, final Set assertions) { + this.name = name; + this.answerSetCountVerifier = answerSetCountVerifier; + this.input = input; + this.assertions = assertions; + } + + @Override + public String getName() { + return name; + } + + @Override + public IntPredicate getAnswerSetCountVerifier() { + return answerSetCountVerifier; + } + + @Override + public Set getInput() { + return input; + } + + @Override + public Set getAssertions() { + return assertions; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java new file mode 100644 index 000000000..76ad045b8 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java @@ -0,0 +1,25 @@ +package at.ac.tuwien.kr.alpha.commons.programs.tests; + +import java.util.Set; +import java.util.function.IntPredicate; + +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; + +public final class Tests { + + private Tests() { + throw new AssertionError("Cannot instantiate utility class!"); + } + + public static TestCase newTestCase(final String name, final IntPredicate answerSetCountVerifier, final Set input, final Set assertions) { + return new TestCaseImpl(name, answerSetCountVerifier, input, assertions); + } + + public static Assertion newAssertion(final Assertion.Mode mode, final ASPCore2Program verifier) { + return new AssertionImpl(mode, verifier); + } + +} diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index 4f80be1a2..dca019d10 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -46,7 +46,9 @@ naf_literals : naf_literal (COMMA naf_literals)?; naf_literal : NAF? (external_atom | classical_literal | builtin_atom); -classical_literal : MINUS? ID (PAREN_OPEN terms PAREN_CLOSE)?; +basic_atom : ID (PAREN_OPEN terms PAREN_CLOSE)?; + +classical_literal : MINUS? basic_atom; builtin_atom : term binop term; @@ -77,10 +79,13 @@ interval_bound : numeral | VARIABLE; external_atom : MINUS? AMPERSAND ID (SQUARE_OPEN input = terms SQUARE_CLOSE)? (PAREN_OPEN output = terms PAREN_CLOSE)?; // NOT Core2 syntax. -directive : directive_enumeration; // NOT Core2 syntax, allows solver specific directives. Further directives shall be added here. +directive : directive_enumeration | directive_test; // NOT Core2 syntax, allows solver specific directives. Further directives shall be added here. directive_enumeration : SHARP 'enumeration_predicate_is' ID DOT; // NOT Core2 syntax, used for aggregate translation. +// Alpha-specific language extension: Unit Tests (-> https://github.com/alpha-asp/Alpha/issues/237) +directive_test : SHARP 'test' ID PAREN_OPEN 'expect' COLON ('unsat' | (binop? NUMBER)) PAREN_CLOSE CURLY_OPEN test_input test_assert+ CURLY_CLOSE; + basic_terms : basic_term (COMMA basic_terms)? ; basic_term : ground_term | variable_term; @@ -91,4 +96,13 @@ variable_term : VARIABLE | ANONYMOUS_VARIABLE; answer_set : CURLY_OPEN classical_literal? (COMMA classical_literal)* CURLY_CLOSE; -answer_sets: answer_set* EOF; \ No newline at end of file +answer_sets : answer_set* EOF; + +test_input : 'input' CURLY_OPEN (basic_atom DOT)* CURLY_CLOSE; + +test_assert : test_assert_all | test_assert_some; + +test_assert_all : 'assert' 'for' 'all' CURLY_OPEN statements? CURLY_CLOSE; + +test_assert_some : 'assert' 'for' 'some' CURLY_OPEN statements? CURLY_CLOSE; + diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 5d77e587d..d8a20efe6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -1,5 +1,5 @@ /** - * Copyright (c) 2016-2018, the Alpha Team. + * Copyright (c) 2016-2023, the Alpha Team. * All rights reserved. *

* Additional changes made by Siemens. @@ -63,6 +63,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; @@ -75,6 +76,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; +import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser.StatementsContext; /** * Copyright (c) 2016-2018, the Alpha Team. @@ -464,15 +466,20 @@ public Literal visitNaf_literal(ASPCore2Parser.Naf_literalContext ctx) { throw notSupported(ctx); } + @Override + public BasicAtom visitBasic_atom(ASPCore2Parser.Basic_atomContext ctx) { + // basic_atom : ID (PAREN_OPEN terms PAREN_CLOSE)?; + List terms = visitTerms(ctx.terms()); + return Atoms.newBasicAtom(Predicates.getPredicate(ctx.ID().getText(), terms.size()), terms); + } + @Override public BasicAtom visitClassical_literal(ASPCore2Parser.Classical_literalContext ctx) { - // classical_literal : MINUS? ID (PAREN_OPEN terms PAREN_CLOSE)?; + // classical_literal : MINUS? basic_atom; if (ctx.MINUS() != null) { throw notSupported(ctx); } - - final List terms = visitTerms(ctx.terms()); - return Atoms.newBasicAtom(Predicates.getPredicate(ctx.ID().getText(), terms.size()), terms); + return visitBasic_atom(ctx.basic_atom()); } @Override @@ -616,4 +623,23 @@ public Object visitTerm_bitxorArithTerm(ASPCore2Parser.Term_bitxorArithTermConte // | term BITXOR term return Terms.newArithmeticTerm((Term) visit(ctx.term(0)), ArithmeticOperator.BITXOR, (Term) visit(ctx.term(1))); } + + @Override + public Assertion visitTest_assert_all(ASPCore2Parser.Test_assert_allContext ctx) { + StatementsContext stmtCtx = ctx.statements(); + if(stmtCtx == null) { // empty verifier for a test case is OK + + } + return null; // TODO + } + + public ASPCore2Program visitTestVerifier(ASPCore2Parser.StatementsContext ctx) { + return null; // TODO + } + + @Override + public Assertion visitTest_assert_some(ASPCore2Parser.Test_assert_someContext ctx) { + return null; // TODO + } + } From 7237490d99a2e3d283316bf310f51d134656fbce Mon Sep 17 00:00:00 2001 From: "michael.langowski@gmx.at" Date: Thu, 2 Mar 2023 23:20:04 +0100 Subject: [PATCH 72/96] parsing for unit tests --- .../alpha/api/programs/ASPCore2Program.java | 10 +- .../alpha/api/programs/tests/Assertion.java | 17 ++- .../commons/programs/ASPCore2ProgramImpl.java | 28 +++- .../commons/programs/AbstractProgram.java | 15 +- .../kr/alpha/commons/programs/Programs.java | 25 +++- .../commons/programs/tests/AssertionImpl.java | 7 +- .../commons/programs/tests/TestCaseImpl.java | 10 +- .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 5 +- .../alpha/core/parser/ParseTreeVisitor.java | 140 +++++++++++++----- .../kr/alpha/core/parser/ParserTest.java | 17 +++ 10 files changed, 208 insertions(+), 66 deletions(-) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java index 24a64615e..fa444b184 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java @@ -2,12 +2,20 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; + +import java.util.List; /** * A {@link Program} that conforms to Alphas implementation of the ASP-Core2-Standard. - * + * * Copyright (c) 2021, the Alpha Team. */ public interface ASPCore2Program extends Program> { + /** + * The test cases associated with this program. + */ + List getTestCases(); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java index 3638603f4..7fd01e5c2 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java @@ -5,12 +5,25 @@ public interface Assertion { enum Mode { - FOR_ALL, - FOR_SOME; + FOR_ALL("for all"), + FOR_SOME("for some"); + + private final String text; + + Mode(String text) { + this.text = text; + } + + @Override + public String toString() { + return text; + } + } Mode getMode(); ASPCore2Program getVerifier(); + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java index 6369053ac..32c5ccacf 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java @@ -27,15 +27,16 @@ */ package at.ac.tuwien.kr.alpha.commons.programs; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.commons.util.Util; + +import java.util.Collections; +import java.util.List; /** * Alpha-internal representation of an ASP program, i.e., a set of ASP rules. @@ -44,14 +45,25 @@ */ class ASPCore2ProgramImpl extends AbstractProgram> implements ASPCore2Program{ - static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl()); + static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl(), Collections.emptyList()); + + private final List testCases; - ASPCore2ProgramImpl(List> rules, List facts, InlineDirectives inlineDirectives) { + ASPCore2ProgramImpl(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { super(rules, facts, inlineDirectives); + this.testCases = testCases; + } + + @Override + public List getTestCases() { + return testCases; } - ASPCore2ProgramImpl() { - super(new ArrayList<>(), new ArrayList<>(), new InlineDirectivesImpl()); + @Override + public String toString() { + String ls = System.lineSeparator(); + final String testsString = testCases.isEmpty() ? "" : Util.join("", testCases, ls, ls); + return super.toString() + testsString; } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java index f78ee2e80..0851167b1 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/AbstractProgram.java @@ -1,14 +1,14 @@ package at.ac.tuwien.kr.alpha.commons.programs; -import java.util.Collections; -import java.util.List; - import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.util.Util; +import java.util.Collections; +import java.util.List; + /** * The parent type for all kinds of programs. Defines a program's basic structure (facts + rules + inlineDirectives) * @@ -40,14 +40,13 @@ public InlineDirectives getInlineDirectives() { return inlineDirectives; } + @Override public String toString() { final String ls = System.lineSeparator(); - final String result = facts.isEmpty() ? "" : Util.join("", facts, "." + ls, "." + ls); - if (rules.isEmpty()) { - return result; - } - return Util.join(result, rules, ls, ls); + final String factString = facts.isEmpty() ? "" : Util.join("", facts, "." + ls, "." + ls); + final String ruleString = rules.isEmpty() ? "" : Util.join("", rules, ls, ls); + return factString + ruleString; } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java index 2bafac832..e42a486fe 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.commons.programs; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; @@ -10,6 +11,7 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; public final class Programs { @@ -22,8 +24,12 @@ public static ASPCore2Program emptyProgram() { return ASPCore2ProgramImpl.EMPTY; } + public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { + return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, testCases); + } + public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { - return new ASPCore2ProgramImpl(rules, facts, inlineDirectives); + return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, Collections.emptyList()); } public static ASPCore2ProgramBuilder builder() { @@ -59,10 +65,13 @@ public static class ASPCore2ProgramBuilder { private List facts = new ArrayList<>(); private InlineDirectives inlineDirectives = new InlineDirectivesImpl(); + private List testCases = new ArrayList<>(); + public ASPCore2ProgramBuilder(ASPCore2Program prog) { this.addRules(prog.getRules()); this.addFacts(prog.getFacts()); this.addInlineDirectives(prog.getInlineDirectives()); + this.addTestCases(prog.getTestCases()); } public ASPCore2ProgramBuilder() { @@ -94,12 +103,22 @@ public ASPCore2ProgramBuilder addInlineDirectives(InlineDirectives inlineDirecti return this; } + public ASPCore2ProgramBuilder addTestCase(TestCase testCase) { + this.testCases.add(testCase); + return this; + } + + public ASPCore2ProgramBuilder addTestCases(List testCases) { + this.testCases.addAll(testCases); + return this; + } + public ASPCore2ProgramBuilder accumulate(ASPCore2Program prog) { - return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()); + return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()).addTestCases(prog.getTestCases()); } public ASPCore2Program build() { - return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives); + return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives, this.testCases); } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java index 36bf901d2..5253a17b1 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java @@ -22,5 +22,10 @@ public Mode getMode() { public ASPCore2Program getVerifier() { return verifier; } - + + @Override + public String toString() { + return "assert " + mode.toString() + "{" + verifier.toString() + "}"; + } + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java index 8b62dafd5..30760957d 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java @@ -6,6 +6,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.commons.util.Util; class TestCaseImpl implements TestCase { @@ -40,5 +41,12 @@ public Set getInput() { public Set getAssertions() { return assertions; } - + + public String toString() { + String ls = System.lineSeparator(); + String inputString = input.isEmpty() ? "" : Util.join("", input, ls, ls); + String assertionsString = assertions.isEmpty() ? "" : Util.join("", assertions, ls, ls); + return "#test " + name + "(expect: " + answerSetCountVerifier.toString() + ") { " + ls + inputString + assertionsString + "}"; + } + } diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index dca019d10..9ce135b53 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -83,8 +83,9 @@ directive : directive_enumeration | directive_test; // NOT Core2 syntax, allows directive_enumeration : SHARP 'enumeration_predicate_is' ID DOT; // NOT Core2 syntax, used for aggregate translation. +// TODO change lexer rules s.t. test-specific keywords can still be used as IDs! // Alpha-specific language extension: Unit Tests (-> https://github.com/alpha-asp/Alpha/issues/237) -directive_test : SHARP 'test' ID PAREN_OPEN 'expect' COLON ('unsat' | (binop? NUMBER)) PAREN_CLOSE CURLY_OPEN test_input test_assert+ CURLY_CLOSE; +directive_test : SHARP 'test' ID PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; basic_terms : basic_term (COMMA basic_terms)? ; @@ -98,6 +99,8 @@ answer_set : CURLY_OPEN classical_literal? (COMMA classical_literal)* CURLY_CLOS answer_sets : answer_set* EOF; +test_satisfiability_condition : 'expect' COLON ('unsat' | (binop? NUMBER)); + test_input : 'input' CURLY_OPEN (basic_atom DOT)* CURLY_CLOSE; test_assert : test_assert_all | test_assert_some; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index d8a20efe6..f2edf0fc5 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -27,43 +27,22 @@ */ package at.ac.tuwien.kr.alpha.core.parser; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.SortedSet; -import java.util.TreeMap; -import java.util.TreeSet; - -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.tree.TerminalNode; - import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.ComparisonAtom; -import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.*; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.*; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; @@ -74,9 +53,14 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.tests.Tests; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2BaseVisitor; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser.StatementsContext; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.tree.TerminalNode; + +import java.util.*; +import java.util.function.IntPredicate; /** * Copyright (c) 2016-2018, the Alpha Team. @@ -85,9 +69,16 @@ public class ParseTreeVisitor extends ASPCore2BaseVisitor { private final Map externals; private final boolean acceptVariables; - private ASPCore2ProgramBuilder programBuilder; private InlineDirectives inlineDirectives; + /* + * Since verifiers for tests are ASP programs in themselves, we need to parse nested programs. + * Therefore, have a stack onto which we "park" a program builder for the outer scope (i.e. main program) + * while we parse the inner scope (i.e. test verifier). + */ + private ASPCore2ProgramBuilder currentLevelProgramBuilder; + private Stack programBuilders = new Stack<>(); + public ParseTreeVisitor(Map externals) { this(externals, true); } @@ -164,10 +155,10 @@ public ASPCore2Program visitProgram(ASPCore2Parser.ProgramContext ctx) { return Programs.emptyProgram(); } inlineDirectives = Programs.newInlineDirectives(); - programBuilder = Programs.builder(); + currentLevelProgramBuilder = Programs.builder(); visitStatements(ctx.statements()); - programBuilder.addInlineDirectives(inlineDirectives); - return programBuilder.build(); + currentLevelProgramBuilder.addInlineDirectives(inlineDirectives); + return currentLevelProgramBuilder.build(); } @Override @@ -184,10 +175,10 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { // head DOT Head head = visitHead(ctx.head()); if (head instanceof NormalHead) { - programBuilder.addFact(((NormalHead) head).getAtom()); + currentLevelProgramBuilder.addFact(((NormalHead) head).getAtom()); } else { // Treat facts with choice or disjunction in the head like a rule. - programBuilder.addRule(Rules.newRule(head, Collections.emptyList())); + currentLevelProgramBuilder.addRule(Rules.newRule(head, Collections.emptyList())); } return null; } @@ -195,14 +186,14 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { @Override public Object visitStatement_constraint(ASPCore2Parser.Statement_constraintContext ctx) { // CONS body DOT - programBuilder.addRule(Rules.newRule(null, visitBody(ctx.body()))); + currentLevelProgramBuilder.addRule(Rules.newRule(null, visitBody(ctx.body()))); return null; } @Override public Object visitStatement_rule(ASPCore2Parser.Statement_ruleContext ctx) { // head CONS body DOT - programBuilder.addRule(Rules.newRule(visitHead(ctx.head()), visitBody(ctx.body()))); + currentLevelProgramBuilder.addRule(Rules.newRule(visitHead(ctx.head()), visitBody(ctx.body()))); return null; } @@ -300,6 +291,25 @@ public Object visitDirective_enumeration(ASPCore2Parser.Directive_enumerationCon return null; } + @Override + public Object visitDirective_test(ASPCore2Parser.Directive_testContext ctx) { + String name = ctx.ID().getText(); + IntPredicate answerSetCountVerifier = visitTest_satisfiability_condition(ctx.test_satisfiability_condition()); + Set input = visitTest_input(ctx.test_input()); + Set assertions; + if (ctx.test_assert() == null) { + assertions = Collections.emptySet(); + } else { + assertions = new LinkedHashSet<>(); + for (ASPCore2Parser.Test_assertContext assertionCtx : ctx.test_assert()) { + assertions.add(visitTest_assert(assertionCtx)); + } + } + TestCase testCase = Tests.newTestCase(name, answerSetCountVerifier, input, assertions); + currentLevelProgramBuilder.addTestCase(testCase); + return null; + } + @Override public List visitBody(ASPCore2Parser.BodyContext ctx) { // body : ( naf_literal | aggregate ) (COMMA body)?; @@ -624,22 +634,70 @@ public Object visitTerm_bitxorArithTerm(ASPCore2Parser.Term_bitxorArithTermConte return Terms.newArithmeticTerm((Term) visit(ctx.term(0)), ArithmeticOperator.BITXOR, (Term) visit(ctx.term(1))); } + public IntPredicate visitTest_satisfiability_condition(ASPCore2Parser.Test_satisfiability_conditionContext ctx) { + // 'expect' COLON ('unsat' | (binop? NUMBER)); + if (ctx.binop() == null && ctx.NUMBER() == null) { + // 'unsat' + return (i) -> i == 0; + } else { + // binop? NUMBER + int num = Integer.valueOf(ctx.NUMBER().getText()); + if (ctx.binop() == null) { + return (i) -> i == num; + } else { + ComparisonOperator op = visitBinop(ctx.binop()); + return (i) -> op.compare(Terms.newConstant(i), Terms.newConstant(num)); + } + } + } + @Override - public Assertion visitTest_assert_all(ASPCore2Parser.Test_assert_allContext ctx) { - StatementsContext stmtCtx = ctx.statements(); - if(stmtCtx == null) { // empty verifier for a test case is OK + public Set visitTest_input(ASPCore2Parser.Test_inputContext ctx) { + if (ctx.basic_atom() == null) { + return Collections.emptySet(); + } + Set result = new LinkedHashSet<>(); + for (ASPCore2Parser.Basic_atomContext atomCtx : ctx.basic_atom()) { + result.add(visitBasic_atom(atomCtx)); + } + return result; + } + public Assertion visitTest_assert(ASPCore2Parser.Test_assertContext ctx) { + if (ctx.test_assert_all() != null) { + return visitTest_assert_all(ctx.test_assert_all()); + } else if (ctx.test_assert_some() != null) { + return visitTest_assert_some(ctx.test_assert_some()); + } else { + throw new IllegalArgumentException("Unsupported assertion mode at: " + ctx.getText()); } - return null; // TODO } - public ASPCore2Program visitTestVerifier(ASPCore2Parser.StatementsContext ctx) { - return null; // TODO + @Override + public Assertion visitTest_assert_all(ASPCore2Parser.Test_assert_allContext ctx) { + // 'assert' 'for' 'all' CURLY_OPEN statements? CURLY_CLOSE; + return visitTestVerifier(Assertion.Mode.FOR_ALL, ctx.statements()); } @Override public Assertion visitTest_assert_some(ASPCore2Parser.Test_assert_someContext ctx) { - return null; // TODO - } + // 'assert' 'for' 'some' CURLY_OPEN statements? CURLY_CLOSE; + return visitTestVerifier(Assertion.Mode.FOR_SOME, ctx.statements()); + } + + public Assertion visitTestVerifier(Assertion.Mode assertionMode, ASPCore2Parser.StatementsContext ctx) { + if (ctx == null) { // empty verifier for a test case is OK + return Tests.newAssertion(assertionMode, Programs.emptyProgram()); + } + List stmts = ctx.statement(); + programBuilders.push(currentLevelProgramBuilder); + currentLevelProgramBuilder = new ASPCore2ProgramBuilder(); + for (ASPCore2Parser.StatementContext stmtCtx : stmts) { + visit(stmtCtx); + } + ASPCore2Program verifier = currentLevelProgramBuilder.build(); + currentLevelProgramBuilder = programBuilders.pop(); + return Tests.newAssertion(assertionMode, verifier); + } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 4f037fda8..5e77a819b 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -40,6 +40,7 @@ import java.util.Optional; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.junit.jupiter.api.Test; @@ -65,6 +66,14 @@ * Copyright (c) 2016, the Alpha Team. */ public class ParserTest { + + private static final String UNIT_TEST_EXPECT_UNSAT = + "p(1). p(2). " + + ":- p(X), p(Y), X + Y = 3." + + "#test this_is_unsat(expect: unsat) {" + + "input {}" + + "}"; + private final ProgramParserImpl parser = new ProgramParserImpl(); @Test @@ -229,4 +238,12 @@ public void stringWithEscapedQuotes() throws IOException { assertEquals("\"a string with \"quotes\"\"", stringWithQuotes); } + @Test + public void unitTestExpectUnsat() { + ASPCore2Program prog = parser.parse(UNIT_TEST_EXPECT_UNSAT); + assertEquals(1, prog.getTestCases().size()); + TestCase tc = prog.getTestCases().get(0); + assertEquals("this_is_unsat", tc.getName()); + } + } From 2e4ffafb19e41087d40713c20c186dbeab665b01 Mon Sep 17 00:00:00 2001 From: "michael.langowski@gmx.at" Date: Fri, 3 Mar 2023 11:03:42 +0100 Subject: [PATCH 73/96] Lexer rules for test-specific reserved words, slight syntax tweaks --- .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 10 +- .../ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 | 8 + alpha-core/src/main/gen/ASPLexer.interp | 167 +++++++++ alpha-core/src/main/gen/ASPLexer.java | 331 ++++++++++++++++++ .../kr/alpha/core/parser/ParserTest.java | 6 +- 5 files changed, 514 insertions(+), 8 deletions(-) create mode 100644 alpha-core/src/main/gen/ASPLexer.interp create mode 100644 alpha-core/src/main/gen/ASPLexer.java diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index 9ce135b53..ef1565fd0 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -85,7 +85,7 @@ directive_enumeration : SHARP 'enumeration_predicate_is' ID DOT; // NOT Core2 s // TODO change lexer rules s.t. test-specific keywords can still be used as IDs! // Alpha-specific language extension: Unit Tests (-> https://github.com/alpha-asp/Alpha/issues/237) -directive_test : SHARP 'test' ID PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; +directive_test : DIRECTIVE_TEST ID PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; basic_terms : basic_term (COMMA basic_terms)? ; @@ -99,13 +99,13 @@ answer_set : CURLY_OPEN classical_literal? (COMMA classical_literal)* CURLY_CLOS answer_sets : answer_set* EOF; -test_satisfiability_condition : 'expect' COLON ('unsat' | (binop? NUMBER)); +test_satisfiability_condition : TEST_EXPECT COLON (TEST_UNSAT | (binop? NUMBER)); -test_input : 'input' CURLY_OPEN (basic_atom DOT)* CURLY_CLOSE; +test_input : TEST_GIVEN CURLY_OPEN (basic_atom DOT)* CURLY_CLOSE; test_assert : test_assert_all | test_assert_some; -test_assert_all : 'assert' 'for' 'all' CURLY_OPEN statements? CURLY_CLOSE; +test_assert_all : TEST_ASSERT_ALL CURLY_OPEN statements? CURLY_CLOSE; -test_assert_some : 'assert' 'for' 'some' CURLY_OPEN statements? CURLY_CLOSE; +test_assert_some : TEST_ASSERT_SOME CURLY_OPEN statements? CURLY_CLOSE; diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 index a900ca342..83cdff8e4 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 @@ -40,6 +40,14 @@ AGGREGATE_MAX : '#max'; AGGREGATE_MIN : '#min'; AGGREGATE_SUM : '#sum'; +DIRECTIVE_TEST : '#test'; +TEST_EXPECT : 'expect'; +TEST_UNSAT : 'unsat'; +TEST_GIVEN : 'given'; +TEST_ASSERT_ALL : 'assertForAll'; +TEST_ASSERT_SOME : 'assertForSome'; + + ID : ('a'..'z') ( 'A'..'Z' | 'a'..'z' | '0'..'9' | '_' )*; VARIABLE : ('A'..'Z') ( 'A'..'Z' | 'a'..'z' | '0'..'9' | '_' )*; NUMBER : '0' | ('1'..'9') ('0'..'9')*; diff --git a/alpha-core/src/main/gen/ASPLexer.interp b/alpha-core/src/main/gen/ASPLexer.interp new file mode 100644 index 000000000..e50d85951 --- /dev/null +++ b/alpha-core/src/main/gen/ASPLexer.interp @@ -0,0 +1,167 @@ +token literal names: +null +'_' +'.' +',' +'?' +':' +';' +'|' +'not' +':-' +':~' +'+' +'-' +'*' +'/' +'**' +'\\' +'^' +'@' +'#' +'&' +'"' +'(' +')' +'[' +']' +'{' +'}' +'=' +null +'<' +'>' +'<=' +'>=' +'#count' +'#max' +'#min' +'#sum' +'#test' +'expect' +'unsat' +'given' +'assertForAll' +'assertForSome' +null +null +null +null +null +null +null + +token symbolic names: +null +ANONYMOUS_VARIABLE +DOT +COMMA +QUERY_MARK +COLON +SEMICOLON +OR +NAF +CONS +WCONS +PLUS +MINUS +TIMES +DIV +POWER +MODULO +BITXOR +AT +SHARP +AMPERSAND +QUOTE +PAREN_OPEN +PAREN_CLOSE +SQUARE_OPEN +SQUARE_CLOSE +CURLY_OPEN +CURLY_CLOSE +EQUAL +UNEQUAL +LESS +GREATER +LESS_OR_EQ +GREATER_OR_EQ +AGGREGATE_COUNT +AGGREGATE_MAX +AGGREGATE_MIN +AGGREGATE_SUM +DIRECTIVE_TEST +TEST_EXPECT +TEST_UNSAT +TEST_GIVEN +TEST_ASSERT_ALL +TEST_ASSERT_SOME +ID +VARIABLE +NUMBER +QUOTED_STRING +COMMENT +MULTI_LINE_COMMEN +BLANK + +rule names: +ANONYMOUS_VARIABLE +DOT +COMMA +QUERY_MARK +COLON +SEMICOLON +OR +NAF +CONS +WCONS +PLUS +MINUS +TIMES +DIV +POWER +MODULO +BITXOR +AT +SHARP +AMPERSAND +QUOTE +PAREN_OPEN +PAREN_CLOSE +SQUARE_OPEN +SQUARE_CLOSE +CURLY_OPEN +CURLY_CLOSE +EQUAL +UNEQUAL +LESS +GREATER +LESS_OR_EQ +GREATER_OR_EQ +AGGREGATE_COUNT +AGGREGATE_MAX +AGGREGATE_MIN +AGGREGATE_SUM +DIRECTIVE_TEST +TEST_EXPECT +TEST_UNSAT +TEST_GIVEN +TEST_ASSERT_ALL +TEST_ASSERT_SOME +ID +VARIABLE +NUMBER +QUOTED_STRING +COMMENT +MULTI_LINE_COMMEN +BLANK + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 50, 317, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 167, 8, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 5, 43, 255, 8, 43, 10, 43, 12, 43, 258, 9, 43, 1, 44, 1, 44, 5, 44, 262, 8, 44, 10, 44, 12, 44, 265, 9, 44, 1, 45, 1, 45, 1, 45, 5, 45, 270, 8, 45, 10, 45, 12, 45, 273, 9, 45, 3, 45, 275, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 281, 8, 46, 10, 46, 12, 46, 284, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 5, 47, 290, 8, 47, 10, 47, 12, 47, 293, 9, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 301, 8, 48, 10, 48, 12, 48, 304, 9, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 4, 49, 312, 8, 49, 11, 49, 12, 49, 313, 1, 49, 1, 49, 2, 282, 302, 0, 50, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 1, 0, 3, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 12, 13, 32, 32, 326, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 1, 101, 1, 0, 0, 0, 3, 103, 1, 0, 0, 0, 5, 105, 1, 0, 0, 0, 7, 107, 1, 0, 0, 0, 9, 109, 1, 0, 0, 0, 11, 111, 1, 0, 0, 0, 13, 113, 1, 0, 0, 0, 15, 115, 1, 0, 0, 0, 17, 119, 1, 0, 0, 0, 19, 122, 1, 0, 0, 0, 21, 125, 1, 0, 0, 0, 23, 127, 1, 0, 0, 0, 25, 129, 1, 0, 0, 0, 27, 131, 1, 0, 0, 0, 29, 133, 1, 0, 0, 0, 31, 136, 1, 0, 0, 0, 33, 138, 1, 0, 0, 0, 35, 140, 1, 0, 0, 0, 37, 142, 1, 0, 0, 0, 39, 144, 1, 0, 0, 0, 41, 146, 1, 0, 0, 0, 43, 148, 1, 0, 0, 0, 45, 150, 1, 0, 0, 0, 47, 152, 1, 0, 0, 0, 49, 154, 1, 0, 0, 0, 51, 156, 1, 0, 0, 0, 53, 158, 1, 0, 0, 0, 55, 160, 1, 0, 0, 0, 57, 166, 1, 0, 0, 0, 59, 168, 1, 0, 0, 0, 61, 170, 1, 0, 0, 0, 63, 172, 1, 0, 0, 0, 65, 175, 1, 0, 0, 0, 67, 178, 1, 0, 0, 0, 69, 185, 1, 0, 0, 0, 71, 190, 1, 0, 0, 0, 73, 195, 1, 0, 0, 0, 75, 200, 1, 0, 0, 0, 77, 206, 1, 0, 0, 0, 79, 213, 1, 0, 0, 0, 81, 219, 1, 0, 0, 0, 83, 225, 1, 0, 0, 0, 85, 238, 1, 0, 0, 0, 87, 252, 1, 0, 0, 0, 89, 259, 1, 0, 0, 0, 91, 274, 1, 0, 0, 0, 93, 276, 1, 0, 0, 0, 95, 287, 1, 0, 0, 0, 97, 296, 1, 0, 0, 0, 99, 311, 1, 0, 0, 0, 101, 102, 5, 95, 0, 0, 102, 2, 1, 0, 0, 0, 103, 104, 5, 46, 0, 0, 104, 4, 1, 0, 0, 0, 105, 106, 5, 44, 0, 0, 106, 6, 1, 0, 0, 0, 107, 108, 5, 63, 0, 0, 108, 8, 1, 0, 0, 0, 109, 110, 5, 58, 0, 0, 110, 10, 1, 0, 0, 0, 111, 112, 5, 59, 0, 0, 112, 12, 1, 0, 0, 0, 113, 114, 5, 124, 0, 0, 114, 14, 1, 0, 0, 0, 115, 116, 5, 110, 0, 0, 116, 117, 5, 111, 0, 0, 117, 118, 5, 116, 0, 0, 118, 16, 1, 0, 0, 0, 119, 120, 5, 58, 0, 0, 120, 121, 5, 45, 0, 0, 121, 18, 1, 0, 0, 0, 122, 123, 5, 58, 0, 0, 123, 124, 5, 126, 0, 0, 124, 20, 1, 0, 0, 0, 125, 126, 5, 43, 0, 0, 126, 22, 1, 0, 0, 0, 127, 128, 5, 45, 0, 0, 128, 24, 1, 0, 0, 0, 129, 130, 5, 42, 0, 0, 130, 26, 1, 0, 0, 0, 131, 132, 5, 47, 0, 0, 132, 28, 1, 0, 0, 0, 133, 134, 5, 42, 0, 0, 134, 135, 5, 42, 0, 0, 135, 30, 1, 0, 0, 0, 136, 137, 5, 92, 0, 0, 137, 32, 1, 0, 0, 0, 138, 139, 5, 94, 0, 0, 139, 34, 1, 0, 0, 0, 140, 141, 5, 64, 0, 0, 141, 36, 1, 0, 0, 0, 142, 143, 5, 35, 0, 0, 143, 38, 1, 0, 0, 0, 144, 145, 5, 38, 0, 0, 145, 40, 1, 0, 0, 0, 146, 147, 5, 34, 0, 0, 147, 42, 1, 0, 0, 0, 148, 149, 5, 40, 0, 0, 149, 44, 1, 0, 0, 0, 150, 151, 5, 41, 0, 0, 151, 46, 1, 0, 0, 0, 152, 153, 5, 91, 0, 0, 153, 48, 1, 0, 0, 0, 154, 155, 5, 93, 0, 0, 155, 50, 1, 0, 0, 0, 156, 157, 5, 123, 0, 0, 157, 52, 1, 0, 0, 0, 158, 159, 5, 125, 0, 0, 159, 54, 1, 0, 0, 0, 160, 161, 5, 61, 0, 0, 161, 56, 1, 0, 0, 0, 162, 163, 5, 60, 0, 0, 163, 167, 5, 62, 0, 0, 164, 165, 5, 33, 0, 0, 165, 167, 5, 61, 0, 0, 166, 162, 1, 0, 0, 0, 166, 164, 1, 0, 0, 0, 167, 58, 1, 0, 0, 0, 168, 169, 5, 60, 0, 0, 169, 60, 1, 0, 0, 0, 170, 171, 5, 62, 0, 0, 171, 62, 1, 0, 0, 0, 172, 173, 5, 60, 0, 0, 173, 174, 5, 61, 0, 0, 174, 64, 1, 0, 0, 0, 175, 176, 5, 62, 0, 0, 176, 177, 5, 61, 0, 0, 177, 66, 1, 0, 0, 0, 178, 179, 5, 35, 0, 0, 179, 180, 5, 99, 0, 0, 180, 181, 5, 111, 0, 0, 181, 182, 5, 117, 0, 0, 182, 183, 5, 110, 0, 0, 183, 184, 5, 116, 0, 0, 184, 68, 1, 0, 0, 0, 185, 186, 5, 35, 0, 0, 186, 187, 5, 109, 0, 0, 187, 188, 5, 97, 0, 0, 188, 189, 5, 120, 0, 0, 189, 70, 1, 0, 0, 0, 190, 191, 5, 35, 0, 0, 191, 192, 5, 109, 0, 0, 192, 193, 5, 105, 0, 0, 193, 194, 5, 110, 0, 0, 194, 72, 1, 0, 0, 0, 195, 196, 5, 35, 0, 0, 196, 197, 5, 115, 0, 0, 197, 198, 5, 117, 0, 0, 198, 199, 5, 109, 0, 0, 199, 74, 1, 0, 0, 0, 200, 201, 5, 35, 0, 0, 201, 202, 5, 116, 0, 0, 202, 203, 5, 101, 0, 0, 203, 204, 5, 115, 0, 0, 204, 205, 5, 116, 0, 0, 205, 76, 1, 0, 0, 0, 206, 207, 5, 101, 0, 0, 207, 208, 5, 120, 0, 0, 208, 209, 5, 112, 0, 0, 209, 210, 5, 101, 0, 0, 210, 211, 5, 99, 0, 0, 211, 212, 5, 116, 0, 0, 212, 78, 1, 0, 0, 0, 213, 214, 5, 117, 0, 0, 214, 215, 5, 110, 0, 0, 215, 216, 5, 115, 0, 0, 216, 217, 5, 97, 0, 0, 217, 218, 5, 116, 0, 0, 218, 80, 1, 0, 0, 0, 219, 220, 5, 103, 0, 0, 220, 221, 5, 105, 0, 0, 221, 222, 5, 118, 0, 0, 222, 223, 5, 101, 0, 0, 223, 224, 5, 110, 0, 0, 224, 82, 1, 0, 0, 0, 225, 226, 5, 97, 0, 0, 226, 227, 5, 115, 0, 0, 227, 228, 5, 115, 0, 0, 228, 229, 5, 101, 0, 0, 229, 230, 5, 114, 0, 0, 230, 231, 5, 116, 0, 0, 231, 232, 5, 70, 0, 0, 232, 233, 5, 111, 0, 0, 233, 234, 5, 114, 0, 0, 234, 235, 5, 65, 0, 0, 235, 236, 5, 108, 0, 0, 236, 237, 5, 108, 0, 0, 237, 84, 1, 0, 0, 0, 238, 239, 5, 97, 0, 0, 239, 240, 5, 115, 0, 0, 240, 241, 5, 115, 0, 0, 241, 242, 5, 101, 0, 0, 242, 243, 5, 114, 0, 0, 243, 244, 5, 116, 0, 0, 244, 245, 5, 70, 0, 0, 245, 246, 5, 111, 0, 0, 246, 247, 5, 114, 0, 0, 247, 248, 5, 83, 0, 0, 248, 249, 5, 111, 0, 0, 249, 250, 5, 109, 0, 0, 250, 251, 5, 101, 0, 0, 251, 86, 1, 0, 0, 0, 252, 256, 2, 97, 122, 0, 253, 255, 7, 0, 0, 0, 254, 253, 1, 0, 0, 0, 255, 258, 1, 0, 0, 0, 256, 254, 1, 0, 0, 0, 256, 257, 1, 0, 0, 0, 257, 88, 1, 0, 0, 0, 258, 256, 1, 0, 0, 0, 259, 263, 2, 65, 90, 0, 260, 262, 7, 0, 0, 0, 261, 260, 1, 0, 0, 0, 262, 265, 1, 0, 0, 0, 263, 261, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 90, 1, 0, 0, 0, 265, 263, 1, 0, 0, 0, 266, 275, 5, 48, 0, 0, 267, 271, 2, 49, 57, 0, 268, 270, 2, 48, 57, 0, 269, 268, 1, 0, 0, 0, 270, 273, 1, 0, 0, 0, 271, 269, 1, 0, 0, 0, 271, 272, 1, 0, 0, 0, 272, 275, 1, 0, 0, 0, 273, 271, 1, 0, 0, 0, 274, 266, 1, 0, 0, 0, 274, 267, 1, 0, 0, 0, 275, 92, 1, 0, 0, 0, 276, 282, 3, 41, 20, 0, 277, 278, 5, 92, 0, 0, 278, 281, 5, 34, 0, 0, 279, 281, 9, 0, 0, 0, 280, 277, 1, 0, 0, 0, 280, 279, 1, 0, 0, 0, 281, 284, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 282, 280, 1, 0, 0, 0, 283, 285, 1, 0, 0, 0, 284, 282, 1, 0, 0, 0, 285, 286, 3, 41, 20, 0, 286, 94, 1, 0, 0, 0, 287, 291, 5, 37, 0, 0, 288, 290, 8, 1, 0, 0, 289, 288, 1, 0, 0, 0, 290, 293, 1, 0, 0, 0, 291, 289, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 294, 1, 0, 0, 0, 293, 291, 1, 0, 0, 0, 294, 295, 6, 47, 0, 0, 295, 96, 1, 0, 0, 0, 296, 297, 5, 37, 0, 0, 297, 298, 5, 42, 0, 0, 298, 302, 1, 0, 0, 0, 299, 301, 9, 0, 0, 0, 300, 299, 1, 0, 0, 0, 301, 304, 1, 0, 0, 0, 302, 303, 1, 0, 0, 0, 302, 300, 1, 0, 0, 0, 303, 305, 1, 0, 0, 0, 304, 302, 1, 0, 0, 0, 305, 306, 5, 42, 0, 0, 306, 307, 5, 37, 0, 0, 307, 308, 1, 0, 0, 0, 308, 309, 6, 48, 0, 0, 309, 98, 1, 0, 0, 0, 310, 312, 7, 2, 0, 0, 311, 310, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 311, 1, 0, 0, 0, 313, 314, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 316, 6, 49, 0, 0, 316, 100, 1, 0, 0, 0, 11, 0, 166, 256, 263, 271, 274, 280, 282, 291, 302, 313, 1, 0, 1, 0] \ No newline at end of file diff --git a/alpha-core/src/main/gen/ASPLexer.java b/alpha-core/src/main/gen/ASPLexer.java new file mode 100644 index 000000000..0bd7f8452 --- /dev/null +++ b/alpha-core/src/main/gen/ASPLexer.java @@ -0,0 +1,331 @@ +// Generated from java-escape by ANTLR 4.11.1 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class ASPLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.11.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ANONYMOUS_VARIABLE=1, DOT=2, COMMA=3, QUERY_MARK=4, COLON=5, SEMICOLON=6, + OR=7, NAF=8, CONS=9, WCONS=10, PLUS=11, MINUS=12, TIMES=13, DIV=14, POWER=15, + MODULO=16, BITXOR=17, AT=18, SHARP=19, AMPERSAND=20, QUOTE=21, PAREN_OPEN=22, + PAREN_CLOSE=23, SQUARE_OPEN=24, SQUARE_CLOSE=25, CURLY_OPEN=26, CURLY_CLOSE=27, + EQUAL=28, UNEQUAL=29, LESS=30, GREATER=31, LESS_OR_EQ=32, GREATER_OR_EQ=33, + AGGREGATE_COUNT=34, AGGREGATE_MAX=35, AGGREGATE_MIN=36, AGGREGATE_SUM=37, + DIRECTIVE_TEST=38, TEST_EXPECT=39, TEST_UNSAT=40, TEST_GIVEN=41, TEST_ASSERT_ALL=42, + TEST_ASSERT_SOME=43, ID=44, VARIABLE=45, NUMBER=46, QUOTED_STRING=47, + COMMENT=48, MULTI_LINE_COMMEN=49, BLANK=50; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "ANONYMOUS_VARIABLE", "DOT", "COMMA", "QUERY_MARK", "COLON", "SEMICOLON", + "OR", "NAF", "CONS", "WCONS", "PLUS", "MINUS", "TIMES", "DIV", "POWER", + "MODULO", "BITXOR", "AT", "SHARP", "AMPERSAND", "QUOTE", "PAREN_OPEN", + "PAREN_CLOSE", "SQUARE_OPEN", "SQUARE_CLOSE", "CURLY_OPEN", "CURLY_CLOSE", + "EQUAL", "UNEQUAL", "LESS", "GREATER", "LESS_OR_EQ", "GREATER_OR_EQ", + "AGGREGATE_COUNT", "AGGREGATE_MAX", "AGGREGATE_MIN", "AGGREGATE_SUM", + "DIRECTIVE_TEST", "TEST_EXPECT", "TEST_UNSAT", "TEST_GIVEN", "TEST_ASSERT_ALL", + "TEST_ASSERT_SOME", "ID", "VARIABLE", "NUMBER", "QUOTED_STRING", "COMMENT", + "MULTI_LINE_COMMEN", "BLANK" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'_'", "'.'", "','", "'?'", "':'", "';'", "'|'", "'not'", "':-'", + "':~'", "'+'", "'-'", "'*'", "'/'", "'**'", "'\\'", "'^'", "'@'", "'#'", + "'&'", "'\"'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'='", null, + "'<'", "'>'", "'<='", "'>='", "'#count'", "'#max'", "'#min'", "'#sum'", + "'#test'", "'expect'", "'unsat'", "'given'", "'assertForAll'", "'assertForSome'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "ANONYMOUS_VARIABLE", "DOT", "COMMA", "QUERY_MARK", "COLON", "SEMICOLON", + "OR", "NAF", "CONS", "WCONS", "PLUS", "MINUS", "TIMES", "DIV", "POWER", + "MODULO", "BITXOR", "AT", "SHARP", "AMPERSAND", "QUOTE", "PAREN_OPEN", + "PAREN_CLOSE", "SQUARE_OPEN", "SQUARE_CLOSE", "CURLY_OPEN", "CURLY_CLOSE", + "EQUAL", "UNEQUAL", "LESS", "GREATER", "LESS_OR_EQ", "GREATER_OR_EQ", + "AGGREGATE_COUNT", "AGGREGATE_MAX", "AGGREGATE_MIN", "AGGREGATE_SUM", + "DIRECTIVE_TEST", "TEST_EXPECT", "TEST_UNSAT", "TEST_GIVEN", "TEST_ASSERT_ALL", + "TEST_ASSERT_SOME", "ID", "VARIABLE", "NUMBER", "QUOTED_STRING", "COMMENT", + "MULTI_LINE_COMMEN", "BLANK" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public ASPLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "ASPLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\u0004\u00002\u013d\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+ + "\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+ + "\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+ + "\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+ + "\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002"+ + "\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002"+ + "\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002"+ + "\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002"+ + "\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002"+ + "\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002"+ + "\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007"+ + "!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007"+ + "&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+ + "+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+ + "0\u00021\u00071\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+ + "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001"+ + "\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001"+ + "\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001"+ + "\n\u0001\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0001"+ + "\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010\u0001"+ + "\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ + "\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+ + "\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001"+ + "\u0019\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u00a7\b\u001c\u0001\u001d\u0001"+ + "\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + " \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ + "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#"+ + "\u0001$\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001"+ + "%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001"+ + "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001("+ + "\u0001(\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ + ")\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001"+ + "+\u0005+\u00ff\b+\n+\f+\u0102\t+\u0001,\u0001,\u0005,\u0106\b,\n,\f,\u0109"+ + "\t,\u0001-\u0001-\u0001-\u0005-\u010e\b-\n-\f-\u0111\t-\u0003-\u0113\b"+ + "-\u0001.\u0001.\u0001.\u0001.\u0005.\u0119\b.\n.\f.\u011c\t.\u0001.\u0001"+ + ".\u0001/\u0001/\u0005/\u0122\b/\n/\f/\u0125\t/\u0001/\u0001/\u00010\u0001"+ + "0\u00010\u00010\u00050\u012d\b0\n0\f0\u0130\t0\u00010\u00010\u00010\u0001"+ + "0\u00010\u00011\u00041\u0138\b1\u000b1\f1\u0139\u00011\u00011\u0002\u011a"+ + "\u012e\u00002\u0001\u0001\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005"+ + "\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019"+ + "\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012%\u0013\'\u0014)\u0015"+ + "+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c9\u001d;\u001e=\u001f"+ + "? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_0a1c2\u0001\u0000\u0003\u0004\u0000"+ + "09AZ__az\u0002\u0000\n\n\r\r\u0003\u0000\t\n\f\r \u0146\u0000\u0001\u0001"+ + "\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001"+ + "\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000"+ + "\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000"+ + "\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000"+ + "\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000"+ + "\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000"+ + "\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000"+ + "\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000"+ + "\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'"+ + "\u0001\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000"+ + "\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000"+ + "\u00001\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005"+ + "\u0001\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000"+ + "\u0000\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000"+ + "\u0000?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C"+ + "\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000"+ + "\u0000\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000"+ + "\u0000M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q"+ + "\u0001\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000"+ + "\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000"+ + "\u0000[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_"+ + "\u0001\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000"+ + "\u0000\u0000\u0001e\u0001\u0000\u0000\u0000\u0003g\u0001\u0000\u0000\u0000"+ + "\u0005i\u0001\u0000\u0000\u0000\u0007k\u0001\u0000\u0000\u0000\tm\u0001"+ + "\u0000\u0000\u0000\u000bo\u0001\u0000\u0000\u0000\rq\u0001\u0000\u0000"+ + "\u0000\u000fs\u0001\u0000\u0000\u0000\u0011w\u0001\u0000\u0000\u0000\u0013"+ + "z\u0001\u0000\u0000\u0000\u0015}\u0001\u0000\u0000\u0000\u0017\u007f\u0001"+ + "\u0000\u0000\u0000\u0019\u0081\u0001\u0000\u0000\u0000\u001b\u0083\u0001"+ + "\u0000\u0000\u0000\u001d\u0085\u0001\u0000\u0000\u0000\u001f\u0088\u0001"+ + "\u0000\u0000\u0000!\u008a\u0001\u0000\u0000\u0000#\u008c\u0001\u0000\u0000"+ + "\u0000%\u008e\u0001\u0000\u0000\u0000\'\u0090\u0001\u0000\u0000\u0000"+ + ")\u0092\u0001\u0000\u0000\u0000+\u0094\u0001\u0000\u0000\u0000-\u0096"+ + "\u0001\u0000\u0000\u0000/\u0098\u0001\u0000\u0000\u00001\u009a\u0001\u0000"+ + "\u0000\u00003\u009c\u0001\u0000\u0000\u00005\u009e\u0001\u0000\u0000\u0000"+ + "7\u00a0\u0001\u0000\u0000\u00009\u00a6\u0001\u0000\u0000\u0000;\u00a8"+ + "\u0001\u0000\u0000\u0000=\u00aa\u0001\u0000\u0000\u0000?\u00ac\u0001\u0000"+ + "\u0000\u0000A\u00af\u0001\u0000\u0000\u0000C\u00b2\u0001\u0000\u0000\u0000"+ + "E\u00b9\u0001\u0000\u0000\u0000G\u00be\u0001\u0000\u0000\u0000I\u00c3"+ + "\u0001\u0000\u0000\u0000K\u00c8\u0001\u0000\u0000\u0000M\u00ce\u0001\u0000"+ + "\u0000\u0000O\u00d5\u0001\u0000\u0000\u0000Q\u00db\u0001\u0000\u0000\u0000"+ + "S\u00e1\u0001\u0000\u0000\u0000U\u00ee\u0001\u0000\u0000\u0000W\u00fc"+ + "\u0001\u0000\u0000\u0000Y\u0103\u0001\u0000\u0000\u0000[\u0112\u0001\u0000"+ + "\u0000\u0000]\u0114\u0001\u0000\u0000\u0000_\u011f\u0001\u0000\u0000\u0000"+ + "a\u0128\u0001\u0000\u0000\u0000c\u0137\u0001\u0000\u0000\u0000ef\u0005"+ + "_\u0000\u0000f\u0002\u0001\u0000\u0000\u0000gh\u0005.\u0000\u0000h\u0004"+ + "\u0001\u0000\u0000\u0000ij\u0005,\u0000\u0000j\u0006\u0001\u0000\u0000"+ + "\u0000kl\u0005?\u0000\u0000l\b\u0001\u0000\u0000\u0000mn\u0005:\u0000"+ + "\u0000n\n\u0001\u0000\u0000\u0000op\u0005;\u0000\u0000p\f\u0001\u0000"+ + "\u0000\u0000qr\u0005|\u0000\u0000r\u000e\u0001\u0000\u0000\u0000st\u0005"+ + "n\u0000\u0000tu\u0005o\u0000\u0000uv\u0005t\u0000\u0000v\u0010\u0001\u0000"+ + "\u0000\u0000wx\u0005:\u0000\u0000xy\u0005-\u0000\u0000y\u0012\u0001\u0000"+ + "\u0000\u0000z{\u0005:\u0000\u0000{|\u0005~\u0000\u0000|\u0014\u0001\u0000"+ + "\u0000\u0000}~\u0005+\u0000\u0000~\u0016\u0001\u0000\u0000\u0000\u007f"+ + "\u0080\u0005-\u0000\u0000\u0080\u0018\u0001\u0000\u0000\u0000\u0081\u0082"+ + "\u0005*\u0000\u0000\u0082\u001a\u0001\u0000\u0000\u0000\u0083\u0084\u0005"+ + "/\u0000\u0000\u0084\u001c\u0001\u0000\u0000\u0000\u0085\u0086\u0005*\u0000"+ + "\u0000\u0086\u0087\u0005*\u0000\u0000\u0087\u001e\u0001\u0000\u0000\u0000"+ + "\u0088\u0089\u0005\\\u0000\u0000\u0089 \u0001\u0000\u0000\u0000\u008a"+ + "\u008b\u0005^\u0000\u0000\u008b\"\u0001\u0000\u0000\u0000\u008c\u008d"+ + "\u0005@\u0000\u0000\u008d$\u0001\u0000\u0000\u0000\u008e\u008f\u0005#"+ + "\u0000\u0000\u008f&\u0001\u0000\u0000\u0000\u0090\u0091\u0005&\u0000\u0000"+ + "\u0091(\u0001\u0000\u0000\u0000\u0092\u0093\u0005\"\u0000\u0000\u0093"+ + "*\u0001\u0000\u0000\u0000\u0094\u0095\u0005(\u0000\u0000\u0095,\u0001"+ + "\u0000\u0000\u0000\u0096\u0097\u0005)\u0000\u0000\u0097.\u0001\u0000\u0000"+ + "\u0000\u0098\u0099\u0005[\u0000\u0000\u00990\u0001\u0000\u0000\u0000\u009a"+ + "\u009b\u0005]\u0000\u0000\u009b2\u0001\u0000\u0000\u0000\u009c\u009d\u0005"+ + "{\u0000\u0000\u009d4\u0001\u0000\u0000\u0000\u009e\u009f\u0005}\u0000"+ + "\u0000\u009f6\u0001\u0000\u0000\u0000\u00a0\u00a1\u0005=\u0000\u0000\u00a1"+ + "8\u0001\u0000\u0000\u0000\u00a2\u00a3\u0005<\u0000\u0000\u00a3\u00a7\u0005"+ + ">\u0000\u0000\u00a4\u00a5\u0005!\u0000\u0000\u00a5\u00a7\u0005=\u0000"+ + "\u0000\u00a6\u00a2\u0001\u0000\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000"+ + "\u0000\u00a7:\u0001\u0000\u0000\u0000\u00a8\u00a9\u0005<\u0000\u0000\u00a9"+ + "<\u0001\u0000\u0000\u0000\u00aa\u00ab\u0005>\u0000\u0000\u00ab>\u0001"+ + "\u0000\u0000\u0000\u00ac\u00ad\u0005<\u0000\u0000\u00ad\u00ae\u0005=\u0000"+ + "\u0000\u00ae@\u0001\u0000\u0000\u0000\u00af\u00b0\u0005>\u0000\u0000\u00b0"+ + "\u00b1\u0005=\u0000\u0000\u00b1B\u0001\u0000\u0000\u0000\u00b2\u00b3\u0005"+ + "#\u0000\u0000\u00b3\u00b4\u0005c\u0000\u0000\u00b4\u00b5\u0005o\u0000"+ + "\u0000\u00b5\u00b6\u0005u\u0000\u0000\u00b6\u00b7\u0005n\u0000\u0000\u00b7"+ + "\u00b8\u0005t\u0000\u0000\u00b8D\u0001\u0000\u0000\u0000\u00b9\u00ba\u0005"+ + "#\u0000\u0000\u00ba\u00bb\u0005m\u0000\u0000\u00bb\u00bc\u0005a\u0000"+ + "\u0000\u00bc\u00bd\u0005x\u0000\u0000\u00bdF\u0001\u0000\u0000\u0000\u00be"+ + "\u00bf\u0005#\u0000\u0000\u00bf\u00c0\u0005m\u0000\u0000\u00c0\u00c1\u0005"+ + "i\u0000\u0000\u00c1\u00c2\u0005n\u0000\u0000\u00c2H\u0001\u0000\u0000"+ + "\u0000\u00c3\u00c4\u0005#\u0000\u0000\u00c4\u00c5\u0005s\u0000\u0000\u00c5"+ + "\u00c6\u0005u\u0000\u0000\u00c6\u00c7\u0005m\u0000\u0000\u00c7J\u0001"+ + "\u0000\u0000\u0000\u00c8\u00c9\u0005#\u0000\u0000\u00c9\u00ca\u0005t\u0000"+ + "\u0000\u00ca\u00cb\u0005e\u0000\u0000\u00cb\u00cc\u0005s\u0000\u0000\u00cc"+ + "\u00cd\u0005t\u0000\u0000\u00cdL\u0001\u0000\u0000\u0000\u00ce\u00cf\u0005"+ + "e\u0000\u0000\u00cf\u00d0\u0005x\u0000\u0000\u00d0\u00d1\u0005p\u0000"+ + "\u0000\u00d1\u00d2\u0005e\u0000\u0000\u00d2\u00d3\u0005c\u0000\u0000\u00d3"+ + "\u00d4\u0005t\u0000\u0000\u00d4N\u0001\u0000\u0000\u0000\u00d5\u00d6\u0005"+ + "u\u0000\u0000\u00d6\u00d7\u0005n\u0000\u0000\u00d7\u00d8\u0005s\u0000"+ + "\u0000\u00d8\u00d9\u0005a\u0000\u0000\u00d9\u00da\u0005t\u0000\u0000\u00da"+ + "P\u0001\u0000\u0000\u0000\u00db\u00dc\u0005g\u0000\u0000\u00dc\u00dd\u0005"+ + "i\u0000\u0000\u00dd\u00de\u0005v\u0000\u0000\u00de\u00df\u0005e\u0000"+ + "\u0000\u00df\u00e0\u0005n\u0000\u0000\u00e0R\u0001\u0000\u0000\u0000\u00e1"+ + "\u00e2\u0005a\u0000\u0000\u00e2\u00e3\u0005s\u0000\u0000\u00e3\u00e4\u0005"+ + "s\u0000\u0000\u00e4\u00e5\u0005e\u0000\u0000\u00e5\u00e6\u0005r\u0000"+ + "\u0000\u00e6\u00e7\u0005t\u0000\u0000\u00e7\u00e8\u0005F\u0000\u0000\u00e8"+ + "\u00e9\u0005o\u0000\u0000\u00e9\u00ea\u0005r\u0000\u0000\u00ea\u00eb\u0005"+ + "A\u0000\u0000\u00eb\u00ec\u0005l\u0000\u0000\u00ec\u00ed\u0005l\u0000"+ + "\u0000\u00edT\u0001\u0000\u0000\u0000\u00ee\u00ef\u0005a\u0000\u0000\u00ef"+ + "\u00f0\u0005s\u0000\u0000\u00f0\u00f1\u0005s\u0000\u0000\u00f1\u00f2\u0005"+ + "e\u0000\u0000\u00f2\u00f3\u0005r\u0000\u0000\u00f3\u00f4\u0005t\u0000"+ + "\u0000\u00f4\u00f5\u0005F\u0000\u0000\u00f5\u00f6\u0005o\u0000\u0000\u00f6"+ + "\u00f7\u0005r\u0000\u0000\u00f7\u00f8\u0005S\u0000\u0000\u00f8\u00f9\u0005"+ + "o\u0000\u0000\u00f9\u00fa\u0005m\u0000\u0000\u00fa\u00fb\u0005e\u0000"+ + "\u0000\u00fbV\u0001\u0000\u0000\u0000\u00fc\u0100\u0002az\u0000\u00fd"+ + "\u00ff\u0007\u0000\u0000\u0000\u00fe\u00fd\u0001\u0000\u0000\u0000\u00ff"+ + "\u0102\u0001\u0000\u0000\u0000\u0100\u00fe\u0001\u0000\u0000\u0000\u0100"+ + "\u0101\u0001\u0000\u0000\u0000\u0101X\u0001\u0000\u0000\u0000\u0102\u0100"+ + "\u0001\u0000\u0000\u0000\u0103\u0107\u0002AZ\u0000\u0104\u0106\u0007\u0000"+ + "\u0000\u0000\u0105\u0104\u0001\u0000\u0000\u0000\u0106\u0109\u0001\u0000"+ + "\u0000\u0000\u0107\u0105\u0001\u0000\u0000\u0000\u0107\u0108\u0001\u0000"+ + "\u0000\u0000\u0108Z\u0001\u0000\u0000\u0000\u0109\u0107\u0001\u0000\u0000"+ + "\u0000\u010a\u0113\u00050\u0000\u0000\u010b\u010f\u000219\u0000\u010c"+ + "\u010e\u000209\u0000\u010d\u010c\u0001\u0000\u0000\u0000\u010e\u0111\u0001"+ + "\u0000\u0000\u0000\u010f\u010d\u0001\u0000\u0000\u0000\u010f\u0110\u0001"+ + "\u0000\u0000\u0000\u0110\u0113\u0001\u0000\u0000\u0000\u0111\u010f\u0001"+ + "\u0000\u0000\u0000\u0112\u010a\u0001\u0000\u0000\u0000\u0112\u010b\u0001"+ + "\u0000\u0000\u0000\u0113\\\u0001\u0000\u0000\u0000\u0114\u011a\u0003)"+ + "\u0014\u0000\u0115\u0116\u0005\\\u0000\u0000\u0116\u0119\u0005\"\u0000"+ + "\u0000\u0117\u0119\t\u0000\u0000\u0000\u0118\u0115\u0001\u0000\u0000\u0000"+ + "\u0118\u0117\u0001\u0000\u0000\u0000\u0119\u011c\u0001\u0000\u0000\u0000"+ + "\u011a\u011b\u0001\u0000\u0000\u0000\u011a\u0118\u0001\u0000\u0000\u0000"+ + "\u011b\u011d\u0001\u0000\u0000\u0000\u011c\u011a\u0001\u0000\u0000\u0000"+ + "\u011d\u011e\u0003)\u0014\u0000\u011e^\u0001\u0000\u0000\u0000\u011f\u0123"+ + "\u0005%\u0000\u0000\u0120\u0122\b\u0001\u0000\u0000\u0121\u0120\u0001"+ + "\u0000\u0000\u0000\u0122\u0125\u0001\u0000\u0000\u0000\u0123\u0121\u0001"+ + "\u0000\u0000\u0000\u0123\u0124\u0001\u0000\u0000\u0000\u0124\u0126\u0001"+ + "\u0000\u0000\u0000\u0125\u0123\u0001\u0000\u0000\u0000\u0126\u0127\u0006"+ + "/\u0000\u0000\u0127`\u0001\u0000\u0000\u0000\u0128\u0129\u0005%\u0000"+ + "\u0000\u0129\u012a\u0005*\u0000\u0000\u012a\u012e\u0001\u0000\u0000\u0000"+ + "\u012b\u012d\t\u0000\u0000\u0000\u012c\u012b\u0001\u0000\u0000\u0000\u012d"+ + "\u0130\u0001\u0000\u0000\u0000\u012e\u012f\u0001\u0000\u0000\u0000\u012e"+ + "\u012c\u0001\u0000\u0000\u0000\u012f\u0131\u0001\u0000\u0000\u0000\u0130"+ + "\u012e\u0001\u0000\u0000\u0000\u0131\u0132\u0005*\u0000\u0000\u0132\u0133"+ + "\u0005%\u0000\u0000\u0133\u0134\u0001\u0000\u0000\u0000\u0134\u0135\u0006"+ + "0\u0000\u0000\u0135b\u0001\u0000\u0000\u0000\u0136\u0138\u0007\u0002\u0000"+ + "\u0000\u0137\u0136\u0001\u0000\u0000\u0000\u0138\u0139\u0001\u0000\u0000"+ + "\u0000\u0139\u0137\u0001\u0000\u0000\u0000\u0139\u013a\u0001\u0000\u0000"+ + "\u0000\u013a\u013b\u0001\u0000\u0000\u0000\u013b\u013c\u00061\u0000\u0000"+ + "\u013cd\u0001\u0000\u0000\u0000\u000b\u0000\u00a6\u0100\u0107\u010f\u0112"+ + "\u0118\u011a\u0123\u012e\u0139\u0001\u0000\u0001\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 5e77a819b..4ea5e82c8 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -70,8 +70,8 @@ public class ParserTest { private static final String UNIT_TEST_EXPECT_UNSAT = "p(1). p(2). " + ":- p(X), p(Y), X + Y = 3." - + "#test this_is_unsat(expect: unsat) {" - + "input {}" + + "#test expected_unsat(expect: unsat) {" + + "given {}" + "}"; private final ProgramParserImpl parser = new ProgramParserImpl(); @@ -243,7 +243,7 @@ public void unitTestExpectUnsat() { ASPCore2Program prog = parser.parse(UNIT_TEST_EXPECT_UNSAT); assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); - assertEquals("this_is_unsat", tc.getName()); + assertEquals("expected_unsat", tc.getName()); } } From 4d1c69ade82f5baac516b1f496296c84a2029127 Mon Sep 17 00:00:00 2001 From: "michael.langowski@gmx.at" Date: Fri, 3 Mar 2023 11:55:18 +0100 Subject: [PATCH 74/96] tests for unit test parsing --- .../alpha/api/programs/tests/Assertion.java | 4 +- .../kr/alpha/api/programs/tests/TestCase.java | 3 +- .../commons/programs/tests/AssertionImpl.java | 2 +- .../commons/programs/tests/TestCaseImpl.java | 13 +++--- .../alpha/commons/programs/tests/Tests.java | 35 ++++++++++++++- alpha-core/.gitignore | 1 + .../alpha/core/parser/ParseTreeVisitor.java | 12 ++--- .../kr/alpha/core/parser/ParserTest.java | 45 +++++++++++++++++++ 8 files changed, 98 insertions(+), 17 deletions(-) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java index 7fd01e5c2..70da34ddc 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java @@ -5,8 +5,8 @@ public interface Assertion { enum Mode { - FOR_ALL("for all"), - FOR_SOME("for some"); + FOR_ALL("forAll"), + FOR_SOME("forSome"); private final String text; diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java index df5c5e82f..0f148dcca 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestCase.java @@ -1,5 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs.tests; +import java.util.List; import java.util.Set; import java.util.function.IntPredicate; @@ -13,6 +14,6 @@ public interface TestCase { Set getInput(); - Set getAssertions(); + List getAssertions(); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java index 5253a17b1..b7f95a5e6 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java @@ -25,7 +25,7 @@ public ASPCore2Program getVerifier() { @Override public String toString() { - return "assert " + mode.toString() + "{" + verifier.toString() + "}"; + return "assert" + mode.toString() + " {" + System.lineSeparator() + verifier.toString() + "}"; } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java index 30760957d..765db2c81 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/TestCaseImpl.java @@ -1,5 +1,6 @@ package at.ac.tuwien.kr.alpha.commons.programs.tests; +import java.util.List; import java.util.Set; import java.util.function.IntPredicate; @@ -13,9 +14,9 @@ class TestCaseImpl implements TestCase { private final String name; private final IntPredicate answerSetCountVerifier; private final Set input; - private final Set assertions; + private final List assertions; - TestCaseImpl(final String name, final IntPredicate answerSetCountVerifier, final Set input, final Set assertions) { + TestCaseImpl(final String name, final IntPredicate answerSetCountVerifier, final Set input, final List assertions) { this.name = name; this.answerSetCountVerifier = answerSetCountVerifier; this.input = input; @@ -38,15 +39,15 @@ public Set getInput() { } @Override - public Set getAssertions() { + public List getAssertions() { return assertions; } public String toString() { String ls = System.lineSeparator(); - String inputString = input.isEmpty() ? "" : Util.join("", input, ls, ls); - String assertionsString = assertions.isEmpty() ? "" : Util.join("", assertions, ls, ls); - return "#test " + name + "(expect: " + answerSetCountVerifier.toString() + ") { " + ls + inputString + assertionsString + "}"; + String inputString = input.isEmpty() ? "" : Util.join("{", input, ls, "}"); + String assertionsString = assertions.isEmpty() ? "" : Util.join(ls, assertions, ls, ls); + return "#test " + name + "(expect: " + answerSetCountVerifier.toString() + ") { " + ls + "given " + inputString + assertionsString + "}"; } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java index 76ad045b8..6ae7d67af 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java @@ -1,12 +1,15 @@ package at.ac.tuwien.kr.alpha.commons.programs.tests; +import java.util.List; import java.util.Set; import java.util.function.IntPredicate; +import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public final class Tests { @@ -14,7 +17,7 @@ private Tests() { throw new AssertionError("Cannot instantiate utility class!"); } - public static TestCase newTestCase(final String name, final IntPredicate answerSetCountVerifier, final Set input, final Set assertions) { + public static TestCase newTestCase(final String name, final IntPredicate answerSetCountVerifier, final Set input, final List assertions) { return new TestCaseImpl(name, answerSetCountVerifier, input, assertions); } @@ -22,4 +25,34 @@ public static Assertion newAssertion(final Assertion.Mode mode, final ASPCore2Pr return new AssertionImpl(mode, verifier); } + public static IntPredicate newIsUnsatCondition() { + return new IntPredicate() { + @Override + public boolean test(int value) { + return value == 0; + } + + @Override + public String toString() { + return "unsat"; + } + + }; + } + + public static IntPredicate newAnswerSetCountCondition(ComparisonOperator cmpOp, int number) { + return new IntPredicate() { + @Override + public boolean test(int value) { + return cmpOp.compare(Terms.newConstant(value), Terms.newConstant(number)); + } + + @Override + public String toString() { + return cmpOp.toString() + " " + Integer.toString(number); + } + + }; + } + } diff --git a/alpha-core/.gitignore b/alpha-core/.gitignore index 84c048a73..c07308f42 100644 --- a/alpha-core/.gitignore +++ b/alpha-core/.gitignore @@ -1 +1,2 @@ /build/ +/src/main/gen/ diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index f2edf0fc5..a1c1b4709 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -296,11 +296,11 @@ public Object visitDirective_test(ASPCore2Parser.Directive_testContext ctx) { String name = ctx.ID().getText(); IntPredicate answerSetCountVerifier = visitTest_satisfiability_condition(ctx.test_satisfiability_condition()); Set input = visitTest_input(ctx.test_input()); - Set assertions; + List assertions; if (ctx.test_assert() == null) { - assertions = Collections.emptySet(); + assertions = Collections.emptyList(); } else { - assertions = new LinkedHashSet<>(); + assertions = new ArrayList<>(); for (ASPCore2Parser.Test_assertContext assertionCtx : ctx.test_assert()) { assertions.add(visitTest_assert(assertionCtx)); } @@ -638,15 +638,15 @@ public IntPredicate visitTest_satisfiability_condition(ASPCore2Parser.Test_satis // 'expect' COLON ('unsat' | (binop? NUMBER)); if (ctx.binop() == null && ctx.NUMBER() == null) { // 'unsat' - return (i) -> i == 0; + return Tests.newIsUnsatCondition(); } else { // binop? NUMBER int num = Integer.valueOf(ctx.NUMBER().getText()); if (ctx.binop() == null) { - return (i) -> i == num; + return Tests.newAnswerSetCountCondition(ComparisonOperators.EQ, num); } else { ComparisonOperator op = visitBinop(ctx.binop()); - return (i) -> op.compare(Terms.newConstant(i), Terms.newConstant(num)); + return Tests.newAnswerSetCountCondition(op, num); } } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 4ea5e82c8..3a9593c74 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -40,6 +40,7 @@ import java.util.Optional; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; @@ -74,6 +75,15 @@ public class ParserTest { + "given {}" + "}"; + private static final String UNIT_TEST_BASIC_TEST = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. } }"; + private static final String UNIT_TEST_MORE_ASSERTIONS = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. } assertForSome { :- not a.} }"; + + private static final String UNIT_TEST_MORE_TCS = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. }} " + + "#test ensure_not_c (expect: 1) { given { b.} assertForAll { :- c. }}"; + private final ProgramParserImpl parser = new ProgramParserImpl(); @Test @@ -244,6 +254,41 @@ public void unitTestExpectUnsat() { assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); assertEquals("expected_unsat", tc.getName()); + assertTrue(tc.getInput().isEmpty()); + assertTrue(tc.getAssertions().isEmpty()); + } + + @Test + public void unitTestBasicTest() { + ASPCore2Program prog = parser.parse(UNIT_TEST_BASIC_TEST); + assertEquals(1, prog.getTestCases().size()); + TestCase tc = prog.getTestCases().get(0); + assertEquals("ensure_a", tc.getName()); + assertEquals(1, tc.getInput().size()); + assertEquals(1, tc.getAssertions().size()); + assertEquals(Assertion.Mode.FOR_ALL, tc.getAssertions().get(0).getMode()); + } + + @Test + public void unitTestMultipleAsserts() { + ASPCore2Program prog = parser.parse(UNIT_TEST_MORE_ASSERTIONS); + assertEquals(1, prog.getTestCases().size()); + TestCase tc = prog.getTestCases().get(0); + assertEquals("ensure_a", tc.getName()); + assertEquals(1, tc.getInput().size()); + assertEquals(2, tc.getAssertions().size()); + assertEquals(Assertion.Mode.FOR_ALL, tc.getAssertions().get(0).getMode()); + assertEquals(Assertion.Mode.FOR_SOME, tc.getAssertions().get(1).getMode()); + } + + @Test + public void unitTestMoreTCs() { + ASPCore2Program prog = parser.parse(UNIT_TEST_MORE_TCS); + assertEquals(2, prog.getTestCases().size()); + TestCase tc1 = prog.getTestCases().get(0); + assertEquals("ensure_a", tc1.getName()); + TestCase tc2 = prog.getTestCases().get(1); + assertEquals("ensure_not_c", tc2.getName()); } } From d79d5569a330a26cf72010579ec98e4e8ca7a68d Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 3 Mar 2023 14:24:06 +0100 Subject: [PATCH 75/96] skeleton implementation for unit test execution --- .../java/at/ac/tuwien/kr/alpha/api/Alpha.java | 6 ++ .../at/ac/tuwien/kr/alpha/api/AnswerSet.java | 18 +++- .../alpha/api/programs/tests/TestResult.java | 30 ++++++ .../alpha/commons/programs/tests/Tests.java | 37 +++++++ .../commons/util/TestExecutionException.java | 13 +++ .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 96 +++++++++++++++---- 6 files changed, 178 insertions(+), 22 deletions(-) create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java index 71a9fbd29..5fa09a7bc 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java @@ -13,6 +13,7 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; /** * Main API entry point for the Alpha ASP system. Provides facilities for parsing, normalizing and solving ASP programs. @@ -156,4 +157,9 @@ public interface Alpha { */ Set reify(ASPCore2Program program); + /** + * Runs all test cases of the given program. + */ + TestResult test(ASPCore2Program program); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java index d5b63f74e..1015fb833 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java @@ -1,12 +1,14 @@ package at.ac.tuwien.kr.alpha.api; -import java.util.List; -import java.util.SortedSet; - import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AtomQuery; +import java.util.List; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; + /** * API representation of an answer set, i.e. a set of atoms that is a model of an ASP program. * @@ -33,4 +35,14 @@ public interface AnswerSet extends Comparable { * List {@link Atom}s in this answer set satisfying the given {@link AnswerSetQuery}. */ List query(AtomQuery query); + + default Set asFacts() { + return getPredicates().stream() + .map(this::getPredicateInstances) + .reduce(new TreeSet(), (left, right) -> { + left.addAll(right); + return left; + }); + } + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java new file mode 100644 index 000000000..d59d3461c --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java @@ -0,0 +1,30 @@ +package at.ac.tuwien.kr.alpha.api.programs.tests; + +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public interface TestResult { + + List getTestCaseResults(); + + interface TestCaseResult { + + String getTestCaseName(); + + Optional answerSetCountVerificationResult(); + + int getAssertionsPassed(); + + int getAssertionsFailed(); + + int getAssertionsSkipped(); + + Map> getAssertionErrors(); + + default boolean isSuccessful() { + return answerSetCountVerificationResult().isEmpty() && getAssertionsFailed() == 0 && getAssertionsSkipped() == 0; + } + + } +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java index 6ae7d67af..226266fb8 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java @@ -1,6 +1,8 @@ package at.ac.tuwien.kr.alpha.commons.programs.tests; import java.util.List; +import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.function.IntPredicate; @@ -9,6 +11,7 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; public final class Tests { @@ -55,4 +58,38 @@ public String toString() { }; } + public static TestResult.TestCaseResult newTestCaseResult(String testCaseName, Optional answerSetCountResult, int assertionsPassed, int assertionsFailed, int assertionsSkipped, Map> assertionErrors) { + return new TestResult.TestCaseResult() { + @Override + public String getTestCaseName() { + return testCaseName; + } + + @Override + public Optional answerSetCountVerificationResult() { + return answerSetCountResult; + } + + @Override + public int getAssertionsPassed() { + return assertionsPassed; + } + + @Override + public int getAssertionsFailed() { + return assertionsFailed; + } + + @Override + public int getAssertionsSkipped() { + return assertionsSkipped; + } + + @Override + public Map> getAssertionErrors() { + return assertionErrors; + } + }; + } + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java new file mode 100644 index 000000000..43ee3845f --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java @@ -0,0 +1,13 @@ +package at.ac.tuwien.kr.alpha.commons.util; + +public class TestExecutionException extends Exception { + + public TestExecutionException(String msg) { + super(msg); + } + + public TestExecutionException(String msg, Throwable t) { + super(msg, t); + } + +} diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index e359284a1..bae99ea0c 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -27,25 +27,6 @@ */ package at.ac.tuwien.kr.alpha.api.impl; -import java.io.IOException; -import java.io.InputStream; -import java.nio.channels.Channels; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.StringUtils; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import com.google.common.annotations.VisibleForTesting; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; @@ -60,11 +41,16 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.reification.Reifier; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.tests.Tests; import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; @@ -79,6 +65,21 @@ import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; +import com.google.common.annotations.VisibleForTesting; +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.channels.Channels; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.*; +import java.util.function.IntPredicate; +import java.util.stream.Collectors; +import java.util.stream.Stream; public class AlphaImpl implements Alpha { @@ -305,4 +306,61 @@ public Set reify(ASPCore2Program program) { return reifier.reifyProgram(program); } + public TestResult test(ASPCore2Program program) { + NormalProgram programUnderTest = normalizeProgram(program); + for (TestCase testCase : program.getTestCases()) { + runTestCase(programUnderTest, testCase, true); // TODO + } + return null; // TODO + } + + private TestResult.TestCaseResult runTestCase(NormalProgram programUnderTest, TestCase testCase, boolean skipOnFailure) { + List facts = new ArrayList<>(programUnderTest.getFacts()); + facts.addAll(testCase.getInput()); + NormalProgram prog = Programs.newNormalProgram(programUnderTest.getRules(), facts, programUnderTest.getInlineDirectives()); + Set answerSets = solve(prog).collect(Collectors.toSet()); + IntPredicate answerSetsVerifier = testCase.getAnswerSetCountVerifier(); + Optional answerSetCountErrMsg; + if (!answerSetsVerifier.test(answerSets.size())) { + answerSetCountErrMsg = Optional.of("Answer Set count incorrect, verifier: " + answerSetsVerifier + " failed, count is " + answerSets.size()); + if (skipOnFailure) { + return Tests.newTestCaseResult(testCase.getName(), answerSetCountErrMsg, 0, 0, testCase.getAssertions().size(), Collections.emptyMap()); + } + } + int passedCnt = 0; + int failedCnt = 0; + Map> assertionErrors = new LinkedHashMap<>(); + for (Assertion assertion : testCase.getAssertions()) { + java.util.function.Predicate assertionMatcher = (as) -> this.answerSetSatisfiesAssertion(as, assertion); + List errorList = assertionErrors.computeIfAbsent(assertion, (ass) -> new ArrayList<>()); + switch (assertion.getMode()) { + case FOR_ALL: + if (!answerSets.stream().allMatch(assertionMatcher)) { + errorList.addAll( + answerSets.stream() + .filter(assertionMatcher.negate()) + .map((as) -> "Universal assertion failed on answer set: " + as) + .collect(Collectors.toSet()) + ); + } + break; + case FOR_SOME: + if (answerSets.stream().noneMatch(assertionMatcher)) { + errorList.add("No answer set matches existential assertion!"); + } + break; + default: + throw new UnsupportedOperationException("Unsupported assertion mode: " + assertion.getMode()); + } + } + return null; // TODO + } + + private boolean answerSetSatisfiesAssertion(AnswerSet as, Assertion assertion) { + ASPCore2Program verifierWithInput = Programs.builder(assertion.getVerifier()).addFacts(new ArrayList<>(as.asFacts())).build(); + return solve(verifierWithInput).findAny().isPresent(); + } + + + } From 10a1d1313c1af270cf4fab73fa0411f5dc247b1e Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 3 Mar 2023 18:39:25 +0100 Subject: [PATCH 76/96] implement unit test execution --- .../alpha/api/programs/tests/TestResult.java | 10 +- .../alpha/commons/programs/tests/Tests.java | 7 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 72 ++---------- .../tuwien/kr/alpha/api/impl/TestRunner.java | 110 ++++++++++++++++++ .../kr/alpha/api/impl/AlphaImplTest.java | 108 ++++++++++++----- 5 files changed, 208 insertions(+), 99 deletions(-) create mode 100644 alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java index d59d3461c..b7d0bff65 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/TestResult.java @@ -8,6 +8,10 @@ public interface TestResult { List getTestCaseResults(); + default boolean isSuccess() { + return getTestCaseResults().stream().allMatch(TestCaseResult::isSuccess); + } + interface TestCaseResult { String getTestCaseName(); @@ -18,12 +22,10 @@ interface TestCaseResult { int getAssertionsFailed(); - int getAssertionsSkipped(); - Map> getAssertionErrors(); - default boolean isSuccessful() { - return answerSetCountVerificationResult().isEmpty() && getAssertionsFailed() == 0 && getAssertionsSkipped() == 0; + default boolean isSuccess() { + return answerSetCountVerificationResult().isEmpty() && getAssertionsFailed() == 0; } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java index 226266fb8..3962e5684 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java @@ -58,7 +58,7 @@ public String toString() { }; } - public static TestResult.TestCaseResult newTestCaseResult(String testCaseName, Optional answerSetCountResult, int assertionsPassed, int assertionsFailed, int assertionsSkipped, Map> assertionErrors) { + public static TestResult.TestCaseResult newTestCaseResult(String testCaseName, Optional answerSetCountResult, int assertionsPassed, int assertionsFailed, Map> assertionErrors) { return new TestResult.TestCaseResult() { @Override public String getTestCaseName() { @@ -80,11 +80,6 @@ public int getAssertionsFailed() { return assertionsFailed; } - @Override - public int getAssertionsSkipped() { - return assertionsSkipped; - } - @Override public Map> getAssertionErrors() { return assertionErrors; diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index bae99ea0c..8534b91b4 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -41,16 +41,12 @@ import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; -import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.reification.Reifier; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.programs.tests.Tests; import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; @@ -76,8 +72,10 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.*; -import java.util.function.IntPredicate; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -87,6 +85,8 @@ public class AlphaImpl implements Alpha { private final SystemConfig config; // Config is initialized with default values. private final ProgramParser parser = new ProgramParserImpl(); + + private final TestRunner testRunner; private final Reifier reifier = new Reifier(() -> { IdGenerator idGen = new IntIdGenerator(0); return () -> Terms.newConstant(idGen.getNextId()); @@ -95,10 +95,11 @@ public class AlphaImpl implements Alpha { public AlphaImpl(SystemConfig cfg) { this.config = cfg; + this.testRunner = new TestRunner(this); } public AlphaImpl() { - this.config = new SystemConfig(); + this(new SystemConfig()); } @Override @@ -288,6 +289,7 @@ public DependencyGraph getDependencyGraph() { public ComponentGraph getComponentGraph() { return compGraph; } + }; } @@ -306,61 +308,9 @@ public Set reify(ASPCore2Program program) { return reifier.reifyProgram(program); } + @Override public TestResult test(ASPCore2Program program) { - NormalProgram programUnderTest = normalizeProgram(program); - for (TestCase testCase : program.getTestCases()) { - runTestCase(programUnderTest, testCase, true); // TODO - } - return null; // TODO - } - - private TestResult.TestCaseResult runTestCase(NormalProgram programUnderTest, TestCase testCase, boolean skipOnFailure) { - List facts = new ArrayList<>(programUnderTest.getFacts()); - facts.addAll(testCase.getInput()); - NormalProgram prog = Programs.newNormalProgram(programUnderTest.getRules(), facts, programUnderTest.getInlineDirectives()); - Set answerSets = solve(prog).collect(Collectors.toSet()); - IntPredicate answerSetsVerifier = testCase.getAnswerSetCountVerifier(); - Optional answerSetCountErrMsg; - if (!answerSetsVerifier.test(answerSets.size())) { - answerSetCountErrMsg = Optional.of("Answer Set count incorrect, verifier: " + answerSetsVerifier + " failed, count is " + answerSets.size()); - if (skipOnFailure) { - return Tests.newTestCaseResult(testCase.getName(), answerSetCountErrMsg, 0, 0, testCase.getAssertions().size(), Collections.emptyMap()); - } - } - int passedCnt = 0; - int failedCnt = 0; - Map> assertionErrors = new LinkedHashMap<>(); - for (Assertion assertion : testCase.getAssertions()) { - java.util.function.Predicate assertionMatcher = (as) -> this.answerSetSatisfiesAssertion(as, assertion); - List errorList = assertionErrors.computeIfAbsent(assertion, (ass) -> new ArrayList<>()); - switch (assertion.getMode()) { - case FOR_ALL: - if (!answerSets.stream().allMatch(assertionMatcher)) { - errorList.addAll( - answerSets.stream() - .filter(assertionMatcher.negate()) - .map((as) -> "Universal assertion failed on answer set: " + as) - .collect(Collectors.toSet()) - ); - } - break; - case FOR_SOME: - if (answerSets.stream().noneMatch(assertionMatcher)) { - errorList.add("No answer set matches existential assertion!"); - } - break; - default: - throw new UnsupportedOperationException("Unsupported assertion mode: " + assertion.getMode()); - } - } - return null; // TODO + return testRunner.test(program); } - private boolean answerSetSatisfiesAssertion(AnswerSet as, Assertion assertion) { - ASPCore2Program verifierWithInput = Programs.builder(assertion.getVerifier()).addFacts(new ArrayList<>(as.asFacts())).build(); - return solve(verifierWithInput).findAny().isPresent(); - } - - - } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java new file mode 100644 index 000000000..338eeb82a --- /dev/null +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java @@ -0,0 +1,110 @@ +package at.ac.tuwien.kr.alpha.api.impl; + +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.AnswerSet; +import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; +import at.ac.tuwien.kr.alpha.commons.programs.Programs; +import at.ac.tuwien.kr.alpha.commons.programs.tests.Tests; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.*; +import java.util.function.IntPredicate; +import java.util.stream.Collectors; + +class TestRunner { + + private static final Logger LOGGER = LoggerFactory.getLogger(TestRunner.class); + + private final Alpha alpha; + + TestRunner(final Alpha alpha) { + this.alpha = alpha; + } + + TestResult test(ASPCore2Program program) { + LOGGER.info("Running unit tests.."); + NormalProgram programUnderTest = alpha.normalizeProgram(program); + List testCaseResults = program.getTestCases().stream() + .map((tc) -> runTestCase(programUnderTest, tc)) + .collect(Collectors.toList()); + return () -> testCaseResults; + } + + private TestResult.TestCaseResult runTestCase(NormalProgram programUnderTest, TestCase testCase) { + LOGGER.info("Running test case " + testCase.getName()); + List facts = new ArrayList<>(programUnderTest.getFacts()); + facts.addAll(testCase.getInput()); + NormalProgram prog = Programs.newNormalProgram(programUnderTest.getRules(), facts, programUnderTest.getInlineDirectives()); + Set answerSets; + try { + answerSets = alpha.solve(prog).collect(Collectors.toSet()); + } catch (Throwable t) { + LOGGER.error("Test execution failed due to internal error", t); + return Tests.newTestCaseResult( + testCase.getName(), Optional.of("Test execution failed due to internal error: " + t.getMessage()), 0, 0, Collections.emptyMap()); + } + IntPredicate answerSetsVerifier = testCase.getAnswerSetCountVerifier(); + Optional answerSetCountErrMsg; + if (!answerSetsVerifier.test(answerSets.size())) { + answerSetCountErrMsg = Optional.of("Answer Set count incorrect, verifier: " + answerSetsVerifier + " failed, count is " + answerSets.size()); + } else { + answerSetCountErrMsg = Optional.empty(); + } + int passedCnt = 0; + int failedCnt = 0; + Map> assertionErrors = new LinkedHashMap<>(); + for (Assertion assertion : testCase.getAssertions()) { + List errors; + try { + errors = evaluateAssertion(answerSets, assertion); + } catch (Throwable t) { + errors = List.of("Test execution failed due to internal error: " + t.getMessage()); + LOGGER.error("Test execution failed due to internal error", t); + } + if (!errors.isEmpty()) { + failedCnt++; + } else { + passedCnt++; + } + + } + return Tests.newTestCaseResult(testCase.getName(), answerSetCountErrMsg, passedCnt, failedCnt, assertionErrors); + } + + private List evaluateAssertion(Set answerSets, Assertion assertion) { + java.util.function.Predicate matcher = (as) -> this.answerSetSatisfiesAssertion(as, assertion); + List errorList = new ArrayList<>(); + switch (assertion.getMode()) { + case FOR_ALL: + if (!answerSets.stream().allMatch(matcher)) { + errorList.addAll( + answerSets.stream() + .filter(matcher.negate()) + .map((as) -> "Universal assertion failed on answer set: " + as) + .collect(Collectors.toSet()) + ); + } + break; + case FOR_SOME: + if (answerSets.stream().noneMatch(matcher)) { + errorList.add("No answer set matches existential assertion!"); + } + break; + default: + throw new UnsupportedOperationException("Unsupported assertion mode: " + assertion.getMode()); + } + return errorList; + } + + private boolean answerSetSatisfiesAssertion(AnswerSet as, Assertion assertion) { + ASPCore2Program verifierWithInput = Programs.builder(assertion.getVerifier()).addFacts(new ArrayList<>(as.asFacts())).build(); + return alpha.solve(verifierWithInput).findAny().isPresent(); + } + +} diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 7bda46edc..a7b54bf41 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -27,34 +27,6 @@ */ package at.ac.tuwien.kr.alpha.api.impl; -import static java.util.Arrays.asList; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptySet; -import static java.util.Collections.singleton; -import static java.util.Collections.singletonList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.nio.file.StandardOpenOption; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; - -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.Heuristic; @@ -68,6 +40,7 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; @@ -82,6 +55,22 @@ import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardOpenOption; +import java.util.*; +import java.util.stream.Collectors; + +import static java.util.Arrays.asList; +import static java.util.Collections.*; +import static org.junit.jupiter.api.Assertions.*; public class AlphaImplTest { @@ -115,6 +104,22 @@ public class AlphaImplTest { + ":- not has_resultstring."; //@formatter:on + private static final String UNIT_TEST_EXPECT_UNSAT = + "p(1). p(2). " + + ":- p(X), p(Y), X + Y = 3." + + "#test expected_unsat(expect: unsat) {" + + "given {}" + + "}"; + + private static final String UNIT_TEST_BASIC_TEST = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. } }"; + private static final String UNIT_TEST_MORE_ASSERTIONS = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. } assertForSome { :- not a.} }"; + + private static final String UNIT_TEST_MORE_TCS = + "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. }} " + + "#test ensure_not_c (expect: 1) { given { b.} assertForAll { :- c. }}"; + private static int invocations; @at.ac.tuwien.kr.alpha.api.externals.Predicate @@ -543,6 +548,53 @@ public void enableStratifiedEvalTest() { "Preprocessed program does not contain fact derived from stratifiable rule, but should!"); } + @Test + public void passingUnitTestExpectUnsat() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_EXPECT_UNSAT); + TestResult testResult = alpha.test(prog); + assertTrue(testResult.isSuccess()); + } + + @Test + public void passingUnitTestBasicTest() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_BASIC_TEST); + TestResult testResult = alpha.test(prog); + assertTrue(testResult.isSuccess()); + assertEquals(1, testResult.getTestCaseResults().size()); + TestResult.TestCaseResult tcResult = testResult.getTestCaseResults().get(0); + assertTrue(tcResult.isSuccess()); + assertEquals(1, tcResult.getAssertionsPassed()); + assertEquals(0, tcResult.getAssertionsFailed()); + assertFalse(tcResult.answerSetCountVerificationResult().isPresent()); + assertTrue(tcResult.getAssertionErrors().isEmpty()); + } + + @Test + public void passingUnitTestMultipleAssertions() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_MORE_ASSERTIONS); + TestResult testResult = alpha.test(prog); + assertTrue(testResult.isSuccess()); + assertEquals(1, testResult.getTestCaseResults().size()); + TestResult.TestCaseResult tcResult = testResult.getTestCaseResults().get(0); + assertTrue(tcResult.isSuccess()); + assertEquals(2, tcResult.getAssertionsPassed()); + assertEquals(0, tcResult.getAssertionsFailed()); + assertFalse(tcResult.answerSetCountVerificationResult().isPresent()); + assertTrue(tcResult.getAssertionErrors().isEmpty()); + } + + @Test + public void passingUnitTestMultipleTestCases() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_MORE_TCS); + TestResult testResult = alpha.test(prog); + assertTrue(testResult.isSuccess()); + assertEquals(2, testResult.getTestCaseResults().size()); + } + /** * Runs a test that formerly caused some sort of exception. */ From 0d0e4bc73f579fd4c78a87d4c1a8369f85b2ef7e Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 3 Mar 2023 19:06:24 +0100 Subject: [PATCH 77/96] commandline option to run unit tests --- .../kr/alpha/api/config/InputConfig.java | 10 ++++++ .../main/java/at/ac/tuwien/kr/alpha/Main.java | 32 +++++++++++++++++++ .../alpha/app/config/CommandLineParser.java | 7 ++++ 3 files changed, 49 insertions(+) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java index 0586ed95c..3a951a81f 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/InputConfig.java @@ -27,6 +27,7 @@ public class InputConfig { public static final boolean DEFAULT_WRITE_XLSX = false; public static final String DEFAULT_XLSX_OUTFILE_PATH = "alphaAnswerSet"; // current directory, files named "alphaAnswerSet.{num}.{ext}" public static final boolean DEFAULT_REIFY_INPUT = false; + public static final boolean DEFAULT_RUN_TESTS = false; private List aspStrings = new ArrayList<>(); private List files = new ArrayList<>(); @@ -41,6 +42,7 @@ public class InputConfig { private boolean writeAnswerSetsAsXlsx = InputConfig.DEFAULT_WRITE_XLSX; private String answerSetFileOutputPath; private boolean reifyInput = InputConfig.DEFAULT_REIFY_INPUT; + private boolean runTests = InputConfig.DEFAULT_RUN_TESTS; private Map predicateMethods = new HashMap<>(); @@ -219,4 +221,12 @@ public void setReifyInput(boolean reifyInput) { this.reifyInput = reifyInput; } + public boolean isRunTests() { + return runTests; + } + + public void setRunTests(boolean runTests) { + this.runTests = runTests; + } + } diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java index 46c992573..853a6d310 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java @@ -33,12 +33,16 @@ import java.io.IOException; import java.io.PrintStream; import java.nio.file.Paths; +import java.util.List; +import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiConsumer; import java.util.stream.Collectors; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import org.apache.commons.cli.ParseException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -102,6 +106,9 @@ public static void main(String[] args) { for (BasicAtom atom : reified) { System.out.println(atom + "."); } + } else if (inputCfg.isRunTests()) { + TestResult result = alpha.test(program); + printTestResult(result); } else { Solver solver; if (inputCfg.isDebugPreprocessing()) { @@ -118,6 +125,7 @@ public static void main(String[] args) { } } + /** * Writes the given {@link DependencyGraph} to the destination passed as the second parameter * @@ -167,6 +175,30 @@ private static void writeNormalProgram(NormalProgram prg, String path) { } } + private static void printTestResult(TestResult result) { + if (result.isSuccess()) { + System.out.println("TEST SUCCESSFUL"); + } else { + System.out.println("TESTS FAILED!"); + } + for (TestResult.TestCaseResult tcResult : result.getTestCaseResults()) { + System.out.println("Test case: " + tcResult.getTestCaseName() + " " + (tcResult.isSuccess() ? "PASSED" : "FAILED") + + ", assertions passed: " + tcResult.getAssertionsPassed() + + ", assertions failed: " + tcResult.getAssertionsFailed()); + if (!tcResult.isSuccess()) { + System.out.println("Assertion failures:"); + if (tcResult.answerSetCountVerificationResult().isPresent()) { + System.out.println(tcResult.answerSetCountVerificationResult().get()); + } + for (Map.Entry> assertionError : tcResult.getAssertionErrors().entrySet()) { + for (String errMsg : assertionError.getValue()) { + System.out.println("Assertion failed: " + assertionError.getKey() + ", error = " + errMsg); + } + } + } + } + } + private static void computeAndConsumeAnswerSets(Solver solver, AlphaConfig alphaCfg) { SystemConfig sysCfg = alphaCfg.getSystemConfig(); InputConfig inputCfg = alphaCfg.getInputConfig(); diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java index fcefe55fc..680cf1678 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java @@ -89,6 +89,7 @@ public class CommandLineParser { private static final Option OPT_WRITE_XSLX = Option.builder("wx").longOpt("write-xlsx").hasArg(true).argName("path").type(String.class) .desc("Write answer sets to excel files, i.e. xlsx workbooks (one workbook per answer set)").build(); private static final Option OPT_REIFY = Option.builder("reify").longOpt("reifyProgram").hasArg(false).desc("Reifies, i.e. encodes as ASP facts, the given program.").build(); + private static final Option OPT_RUN_TESTS = Option.builder("t").longOpt("--run-tests").hasArg(false).desc("Runs all unit tests of the given ASP Program").build(); // general system-wide config private static final Option OPT_GROUNDER = Option.builder("g").longOpt("grounder").hasArg(true).argName("grounder") @@ -168,6 +169,7 @@ public class CommandLineParser { CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_DEBUG_PREPROCESSING); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_WRITE_XSLX); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_REIFY); + CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_RUN_TESTS); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER); CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_SOLVER); @@ -259,6 +261,7 @@ private void initializeInputOptionHandlers() { this.inputOptionHandlers.put(CommandLineParser.OPT_DEBUG_PREPROCESSING.getOpt(), this::handleDebugPreprocessing); this.inputOptionHandlers.put(CommandLineParser.OPT_WRITE_XSLX.getOpt(), this::handleWriteXlsx); this.inputOptionHandlers.put(CommandLineParser.OPT_REIFY.getOpt(), this::handleReify); + this.inputOptionHandlers.put(CommandLineParser.OPT_RUN_TESTS.getOpt(), this::handleRunTests); } public AlphaConfig parseCommandLine(String[] args) throws ParseException { @@ -432,6 +435,10 @@ private void handleReify(Option opt, InputConfig cfg) { cfg.setReifyInput(true); } + private void handleRunTests(Option opt, InputConfig cfg) { + cfg.setRunTests(true); + } + private void handleStats(Option opt, SystemConfig cfg) { cfg.setPrintStats(true); } From ecc9bbd2c9962624e14883ef12b4e1d026a031b7 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 3 Mar 2023 19:32:10 +0100 Subject: [PATCH 78/96] add 3-coloring example with unit tests --- .../alpha/app/config/CommandLineParser.java | 2 +- examples/3col_with_tests.asp | 66 +++++++++++++++++++ 2 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 examples/3col_with_tests.asp diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java index 680cf1678..857705f97 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java @@ -89,7 +89,7 @@ public class CommandLineParser { private static final Option OPT_WRITE_XSLX = Option.builder("wx").longOpt("write-xlsx").hasArg(true).argName("path").type(String.class) .desc("Write answer sets to excel files, i.e. xlsx workbooks (one workbook per answer set)").build(); private static final Option OPT_REIFY = Option.builder("reify").longOpt("reifyProgram").hasArg(false).desc("Reifies, i.e. encodes as ASP facts, the given program.").build(); - private static final Option OPT_RUN_TESTS = Option.builder("t").longOpt("--run-tests").hasArg(false).desc("Runs all unit tests of the given ASP Program").build(); + private static final Option OPT_RUN_TESTS = Option.builder("t").longOpt("run-tests").hasArg(false).desc("Runs all unit tests of the given ASP Program").build(); // general system-wide config private static final Option OPT_GROUNDER = Option.builder("g").longOpt("grounder").hasArg(true).argName("grounder") diff --git a/examples/3col_with_tests.asp b/examples/3col_with_tests.asp new file mode 100644 index 000000000..8f57337e0 --- /dev/null +++ b/examples/3col_with_tests.asp @@ -0,0 +1,66 @@ +%%% Basic Encoding of the Graph 3-Coloring Problem %%% +% Graphs are interpreted as having undirected edges. + +% Edges are undirected +edge(Y, X) :- edge(X, Y). + +% Guess color for each vertex +red(V) :- vertex(V), not green(V), not blue(V). +green(V) :- vertex(V), not red(V), not blue(V). +blue(V) :- vertex(V), not red(V), not green(V). + +% Check for invalid colorings +:- vertex(V1), vertex(V2), edge(V1, V2), red(V1), red(V2). +:- vertex(V1), vertex(V2), edge(V1, V2), green(V1), green(V2). +:- vertex(V1), vertex(V2), edge(V1, V2), blue(V1), blue(V2). + +%% Verify that directed edges are converted to undirected ones. +#test no_asymmetric_edge(expect: >0) { + given { + vertex(a). + vertex(b). + vertex(c). + edge(a, b). + edge(b, c). + edge(c, a). + } + assertForAll { + :- edge(A, B), not edge(B, A). + } +} + +#test triangle_colorings(expect: 6) { + given { + vertex(a). + vertex(b). + vertex(c). + edge(a, b). + edge(b, c). + edge(c, a). + } + % Make sure all vertices are colored in all answer sets + assertForAll { + colored(V) :- vertex(V), red(V). + colored(V) :- vertex(V), green(V). + colored(V) :- vertex(V), blue(V). + :- vertex(V), not colored(V). + } + % Make sure we do not have neighboring vertices of same color in any answer set + assertForAll { + :- edge(V1, V2), red(V1), red(V2). + :- edge(V1, V2), green(V1), green(V2). + :- edge(V1, V2), blue(V1), blue(V2). + } + % In at least one answer set, vertex a should be red + assertForSome { + :- not red(a). + } + % In at least one answer set, vertex a should be green + assertForSome { + :- not green(a). + } + % In at least one answer set, vertex a should be blue + assertForSome { + :- not blue(a). + } +} From 6248871b30dc41c4aa46c56bab73da660739f940 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 5 Mar 2023 13:33:34 +0100 Subject: [PATCH 79/96] add assertion error messages to test result --- .../main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java index 338eeb82a..2ac4bce95 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java @@ -69,10 +69,10 @@ private TestResult.TestCaseResult runTestCase(NormalProgram programUnderTest, Te } if (!errors.isEmpty()) { failedCnt++; + assertionErrors.put(assertion, errors); } else { passedCnt++; } - } return Tests.newTestCaseResult(testCase.getName(), answerSetCountErrMsg, passedCnt, failedCnt, assertionErrors); } From be855678f04b6d53d896420ae74f1fda2017e437 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 5 Mar 2023 13:45:49 +0100 Subject: [PATCH 80/96] negative tests for unit test support --- .../kr/alpha/api/impl/AlphaImplTest.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index a7b54bf41..9a774a18b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -120,6 +120,12 @@ public class AlphaImplTest { "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. }} " + "#test ensure_not_c (expect: 1) { given { b.} assertForAll { :- c. }}"; + private static final String UNIT_TEST_FAILING_ASSERTION = + "a :- b. #test ensure_c(expect: 1) { given { b. } assertForAll { :- not c. } }"; + + private static final String UNIT_TEST_FAILING_COUNT = + "a :- b. #test ensure_a(expect: 2) { given { b. } assertForAll { :- not a. } }"; + private static int invocations; @at.ac.tuwien.kr.alpha.api.externals.Predicate @@ -595,6 +601,35 @@ public void passingUnitTestMultipleTestCases() { assertEquals(2, testResult.getTestCaseResults().size()); } + @Test + public void failingAssertionUnitTest() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_FAILING_ASSERTION); + TestResult testResult = alpha.test(prog); + assertFalse(testResult.isSuccess()); + assertEquals(1, testResult.getTestCaseResults().size()); + TestResult.TestCaseResult tcResult = testResult.getTestCaseResults().get(0); + assertFalse(tcResult.isSuccess()); + assertEquals(0, tcResult.getAssertionsPassed()); + assertEquals(1, tcResult.getAssertionsFailed()); + assertFalse(tcResult.answerSetCountVerificationResult().isPresent()); + assertEquals(1, tcResult.getAssertionErrors().size()); + } + + @Test + public void failingAnswerSetCountUnitTest() { + Alpha alpha = new AlphaImpl(); + ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_FAILING_COUNT); + TestResult testResult = alpha.test(prog); + assertFalse(testResult.isSuccess()); + assertEquals(1, testResult.getTestCaseResults().size()); + TestResult.TestCaseResult tcResult = testResult.getTestCaseResults().get(0); + assertFalse(tcResult.isSuccess()); + assertEquals(1, tcResult.getAssertionsPassed()); + assertEquals(0, tcResult.getAssertionsFailed()); + assertTrue(tcResult.answerSetCountVerificationResult().isPresent()); + } + /** * Runs a test that formerly caused some sort of exception. */ From a9d442b26ed2603d352c0d978ecb49d129fbe14d Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 5 Mar 2023 13:46:57 +0100 Subject: [PATCH 81/96] delete accidentally commited generated source files --- alpha-core/src/main/gen/ASPLexer.interp | 167 ------------ alpha-core/src/main/gen/ASPLexer.java | 331 ------------------------ 2 files changed, 498 deletions(-) delete mode 100644 alpha-core/src/main/gen/ASPLexer.interp delete mode 100644 alpha-core/src/main/gen/ASPLexer.java diff --git a/alpha-core/src/main/gen/ASPLexer.interp b/alpha-core/src/main/gen/ASPLexer.interp deleted file mode 100644 index e50d85951..000000000 --- a/alpha-core/src/main/gen/ASPLexer.interp +++ /dev/null @@ -1,167 +0,0 @@ -token literal names: -null -'_' -'.' -',' -'?' -':' -';' -'|' -'not' -':-' -':~' -'+' -'-' -'*' -'/' -'**' -'\\' -'^' -'@' -'#' -'&' -'"' -'(' -')' -'[' -']' -'{' -'}' -'=' -null -'<' -'>' -'<=' -'>=' -'#count' -'#max' -'#min' -'#sum' -'#test' -'expect' -'unsat' -'given' -'assertForAll' -'assertForSome' -null -null -null -null -null -null -null - -token symbolic names: -null -ANONYMOUS_VARIABLE -DOT -COMMA -QUERY_MARK -COLON -SEMICOLON -OR -NAF -CONS -WCONS -PLUS -MINUS -TIMES -DIV -POWER -MODULO -BITXOR -AT -SHARP -AMPERSAND -QUOTE -PAREN_OPEN -PAREN_CLOSE -SQUARE_OPEN -SQUARE_CLOSE -CURLY_OPEN -CURLY_CLOSE -EQUAL -UNEQUAL -LESS -GREATER -LESS_OR_EQ -GREATER_OR_EQ -AGGREGATE_COUNT -AGGREGATE_MAX -AGGREGATE_MIN -AGGREGATE_SUM -DIRECTIVE_TEST -TEST_EXPECT -TEST_UNSAT -TEST_GIVEN -TEST_ASSERT_ALL -TEST_ASSERT_SOME -ID -VARIABLE -NUMBER -QUOTED_STRING -COMMENT -MULTI_LINE_COMMEN -BLANK - -rule names: -ANONYMOUS_VARIABLE -DOT -COMMA -QUERY_MARK -COLON -SEMICOLON -OR -NAF -CONS -WCONS -PLUS -MINUS -TIMES -DIV -POWER -MODULO -BITXOR -AT -SHARP -AMPERSAND -QUOTE -PAREN_OPEN -PAREN_CLOSE -SQUARE_OPEN -SQUARE_CLOSE -CURLY_OPEN -CURLY_CLOSE -EQUAL -UNEQUAL -LESS -GREATER -LESS_OR_EQ -GREATER_OR_EQ -AGGREGATE_COUNT -AGGREGATE_MAX -AGGREGATE_MIN -AGGREGATE_SUM -DIRECTIVE_TEST -TEST_EXPECT -TEST_UNSAT -TEST_GIVEN -TEST_ASSERT_ALL -TEST_ASSERT_SOME -ID -VARIABLE -NUMBER -QUOTED_STRING -COMMENT -MULTI_LINE_COMMEN -BLANK - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE - -atn: -[4, 0, 50, 317, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 167, 8, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 5, 43, 255, 8, 43, 10, 43, 12, 43, 258, 9, 43, 1, 44, 1, 44, 5, 44, 262, 8, 44, 10, 44, 12, 44, 265, 9, 44, 1, 45, 1, 45, 1, 45, 5, 45, 270, 8, 45, 10, 45, 12, 45, 273, 9, 45, 3, 45, 275, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 281, 8, 46, 10, 46, 12, 46, 284, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 5, 47, 290, 8, 47, 10, 47, 12, 47, 293, 9, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 301, 8, 48, 10, 48, 12, 48, 304, 9, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 4, 49, 312, 8, 49, 11, 49, 12, 49, 313, 1, 49, 1, 49, 2, 282, 302, 0, 50, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 1, 0, 3, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 12, 13, 32, 32, 326, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 1, 101, 1, 0, 0, 0, 3, 103, 1, 0, 0, 0, 5, 105, 1, 0, 0, 0, 7, 107, 1, 0, 0, 0, 9, 109, 1, 0, 0, 0, 11, 111, 1, 0, 0, 0, 13, 113, 1, 0, 0, 0, 15, 115, 1, 0, 0, 0, 17, 119, 1, 0, 0, 0, 19, 122, 1, 0, 0, 0, 21, 125, 1, 0, 0, 0, 23, 127, 1, 0, 0, 0, 25, 129, 1, 0, 0, 0, 27, 131, 1, 0, 0, 0, 29, 133, 1, 0, 0, 0, 31, 136, 1, 0, 0, 0, 33, 138, 1, 0, 0, 0, 35, 140, 1, 0, 0, 0, 37, 142, 1, 0, 0, 0, 39, 144, 1, 0, 0, 0, 41, 146, 1, 0, 0, 0, 43, 148, 1, 0, 0, 0, 45, 150, 1, 0, 0, 0, 47, 152, 1, 0, 0, 0, 49, 154, 1, 0, 0, 0, 51, 156, 1, 0, 0, 0, 53, 158, 1, 0, 0, 0, 55, 160, 1, 0, 0, 0, 57, 166, 1, 0, 0, 0, 59, 168, 1, 0, 0, 0, 61, 170, 1, 0, 0, 0, 63, 172, 1, 0, 0, 0, 65, 175, 1, 0, 0, 0, 67, 178, 1, 0, 0, 0, 69, 185, 1, 0, 0, 0, 71, 190, 1, 0, 0, 0, 73, 195, 1, 0, 0, 0, 75, 200, 1, 0, 0, 0, 77, 206, 1, 0, 0, 0, 79, 213, 1, 0, 0, 0, 81, 219, 1, 0, 0, 0, 83, 225, 1, 0, 0, 0, 85, 238, 1, 0, 0, 0, 87, 252, 1, 0, 0, 0, 89, 259, 1, 0, 0, 0, 91, 274, 1, 0, 0, 0, 93, 276, 1, 0, 0, 0, 95, 287, 1, 0, 0, 0, 97, 296, 1, 0, 0, 0, 99, 311, 1, 0, 0, 0, 101, 102, 5, 95, 0, 0, 102, 2, 1, 0, 0, 0, 103, 104, 5, 46, 0, 0, 104, 4, 1, 0, 0, 0, 105, 106, 5, 44, 0, 0, 106, 6, 1, 0, 0, 0, 107, 108, 5, 63, 0, 0, 108, 8, 1, 0, 0, 0, 109, 110, 5, 58, 0, 0, 110, 10, 1, 0, 0, 0, 111, 112, 5, 59, 0, 0, 112, 12, 1, 0, 0, 0, 113, 114, 5, 124, 0, 0, 114, 14, 1, 0, 0, 0, 115, 116, 5, 110, 0, 0, 116, 117, 5, 111, 0, 0, 117, 118, 5, 116, 0, 0, 118, 16, 1, 0, 0, 0, 119, 120, 5, 58, 0, 0, 120, 121, 5, 45, 0, 0, 121, 18, 1, 0, 0, 0, 122, 123, 5, 58, 0, 0, 123, 124, 5, 126, 0, 0, 124, 20, 1, 0, 0, 0, 125, 126, 5, 43, 0, 0, 126, 22, 1, 0, 0, 0, 127, 128, 5, 45, 0, 0, 128, 24, 1, 0, 0, 0, 129, 130, 5, 42, 0, 0, 130, 26, 1, 0, 0, 0, 131, 132, 5, 47, 0, 0, 132, 28, 1, 0, 0, 0, 133, 134, 5, 42, 0, 0, 134, 135, 5, 42, 0, 0, 135, 30, 1, 0, 0, 0, 136, 137, 5, 92, 0, 0, 137, 32, 1, 0, 0, 0, 138, 139, 5, 94, 0, 0, 139, 34, 1, 0, 0, 0, 140, 141, 5, 64, 0, 0, 141, 36, 1, 0, 0, 0, 142, 143, 5, 35, 0, 0, 143, 38, 1, 0, 0, 0, 144, 145, 5, 38, 0, 0, 145, 40, 1, 0, 0, 0, 146, 147, 5, 34, 0, 0, 147, 42, 1, 0, 0, 0, 148, 149, 5, 40, 0, 0, 149, 44, 1, 0, 0, 0, 150, 151, 5, 41, 0, 0, 151, 46, 1, 0, 0, 0, 152, 153, 5, 91, 0, 0, 153, 48, 1, 0, 0, 0, 154, 155, 5, 93, 0, 0, 155, 50, 1, 0, 0, 0, 156, 157, 5, 123, 0, 0, 157, 52, 1, 0, 0, 0, 158, 159, 5, 125, 0, 0, 159, 54, 1, 0, 0, 0, 160, 161, 5, 61, 0, 0, 161, 56, 1, 0, 0, 0, 162, 163, 5, 60, 0, 0, 163, 167, 5, 62, 0, 0, 164, 165, 5, 33, 0, 0, 165, 167, 5, 61, 0, 0, 166, 162, 1, 0, 0, 0, 166, 164, 1, 0, 0, 0, 167, 58, 1, 0, 0, 0, 168, 169, 5, 60, 0, 0, 169, 60, 1, 0, 0, 0, 170, 171, 5, 62, 0, 0, 171, 62, 1, 0, 0, 0, 172, 173, 5, 60, 0, 0, 173, 174, 5, 61, 0, 0, 174, 64, 1, 0, 0, 0, 175, 176, 5, 62, 0, 0, 176, 177, 5, 61, 0, 0, 177, 66, 1, 0, 0, 0, 178, 179, 5, 35, 0, 0, 179, 180, 5, 99, 0, 0, 180, 181, 5, 111, 0, 0, 181, 182, 5, 117, 0, 0, 182, 183, 5, 110, 0, 0, 183, 184, 5, 116, 0, 0, 184, 68, 1, 0, 0, 0, 185, 186, 5, 35, 0, 0, 186, 187, 5, 109, 0, 0, 187, 188, 5, 97, 0, 0, 188, 189, 5, 120, 0, 0, 189, 70, 1, 0, 0, 0, 190, 191, 5, 35, 0, 0, 191, 192, 5, 109, 0, 0, 192, 193, 5, 105, 0, 0, 193, 194, 5, 110, 0, 0, 194, 72, 1, 0, 0, 0, 195, 196, 5, 35, 0, 0, 196, 197, 5, 115, 0, 0, 197, 198, 5, 117, 0, 0, 198, 199, 5, 109, 0, 0, 199, 74, 1, 0, 0, 0, 200, 201, 5, 35, 0, 0, 201, 202, 5, 116, 0, 0, 202, 203, 5, 101, 0, 0, 203, 204, 5, 115, 0, 0, 204, 205, 5, 116, 0, 0, 205, 76, 1, 0, 0, 0, 206, 207, 5, 101, 0, 0, 207, 208, 5, 120, 0, 0, 208, 209, 5, 112, 0, 0, 209, 210, 5, 101, 0, 0, 210, 211, 5, 99, 0, 0, 211, 212, 5, 116, 0, 0, 212, 78, 1, 0, 0, 0, 213, 214, 5, 117, 0, 0, 214, 215, 5, 110, 0, 0, 215, 216, 5, 115, 0, 0, 216, 217, 5, 97, 0, 0, 217, 218, 5, 116, 0, 0, 218, 80, 1, 0, 0, 0, 219, 220, 5, 103, 0, 0, 220, 221, 5, 105, 0, 0, 221, 222, 5, 118, 0, 0, 222, 223, 5, 101, 0, 0, 223, 224, 5, 110, 0, 0, 224, 82, 1, 0, 0, 0, 225, 226, 5, 97, 0, 0, 226, 227, 5, 115, 0, 0, 227, 228, 5, 115, 0, 0, 228, 229, 5, 101, 0, 0, 229, 230, 5, 114, 0, 0, 230, 231, 5, 116, 0, 0, 231, 232, 5, 70, 0, 0, 232, 233, 5, 111, 0, 0, 233, 234, 5, 114, 0, 0, 234, 235, 5, 65, 0, 0, 235, 236, 5, 108, 0, 0, 236, 237, 5, 108, 0, 0, 237, 84, 1, 0, 0, 0, 238, 239, 5, 97, 0, 0, 239, 240, 5, 115, 0, 0, 240, 241, 5, 115, 0, 0, 241, 242, 5, 101, 0, 0, 242, 243, 5, 114, 0, 0, 243, 244, 5, 116, 0, 0, 244, 245, 5, 70, 0, 0, 245, 246, 5, 111, 0, 0, 246, 247, 5, 114, 0, 0, 247, 248, 5, 83, 0, 0, 248, 249, 5, 111, 0, 0, 249, 250, 5, 109, 0, 0, 250, 251, 5, 101, 0, 0, 251, 86, 1, 0, 0, 0, 252, 256, 2, 97, 122, 0, 253, 255, 7, 0, 0, 0, 254, 253, 1, 0, 0, 0, 255, 258, 1, 0, 0, 0, 256, 254, 1, 0, 0, 0, 256, 257, 1, 0, 0, 0, 257, 88, 1, 0, 0, 0, 258, 256, 1, 0, 0, 0, 259, 263, 2, 65, 90, 0, 260, 262, 7, 0, 0, 0, 261, 260, 1, 0, 0, 0, 262, 265, 1, 0, 0, 0, 263, 261, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 90, 1, 0, 0, 0, 265, 263, 1, 0, 0, 0, 266, 275, 5, 48, 0, 0, 267, 271, 2, 49, 57, 0, 268, 270, 2, 48, 57, 0, 269, 268, 1, 0, 0, 0, 270, 273, 1, 0, 0, 0, 271, 269, 1, 0, 0, 0, 271, 272, 1, 0, 0, 0, 272, 275, 1, 0, 0, 0, 273, 271, 1, 0, 0, 0, 274, 266, 1, 0, 0, 0, 274, 267, 1, 0, 0, 0, 275, 92, 1, 0, 0, 0, 276, 282, 3, 41, 20, 0, 277, 278, 5, 92, 0, 0, 278, 281, 5, 34, 0, 0, 279, 281, 9, 0, 0, 0, 280, 277, 1, 0, 0, 0, 280, 279, 1, 0, 0, 0, 281, 284, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 282, 280, 1, 0, 0, 0, 283, 285, 1, 0, 0, 0, 284, 282, 1, 0, 0, 0, 285, 286, 3, 41, 20, 0, 286, 94, 1, 0, 0, 0, 287, 291, 5, 37, 0, 0, 288, 290, 8, 1, 0, 0, 289, 288, 1, 0, 0, 0, 290, 293, 1, 0, 0, 0, 291, 289, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 294, 1, 0, 0, 0, 293, 291, 1, 0, 0, 0, 294, 295, 6, 47, 0, 0, 295, 96, 1, 0, 0, 0, 296, 297, 5, 37, 0, 0, 297, 298, 5, 42, 0, 0, 298, 302, 1, 0, 0, 0, 299, 301, 9, 0, 0, 0, 300, 299, 1, 0, 0, 0, 301, 304, 1, 0, 0, 0, 302, 303, 1, 0, 0, 0, 302, 300, 1, 0, 0, 0, 303, 305, 1, 0, 0, 0, 304, 302, 1, 0, 0, 0, 305, 306, 5, 42, 0, 0, 306, 307, 5, 37, 0, 0, 307, 308, 1, 0, 0, 0, 308, 309, 6, 48, 0, 0, 309, 98, 1, 0, 0, 0, 310, 312, 7, 2, 0, 0, 311, 310, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 311, 1, 0, 0, 0, 313, 314, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 316, 6, 49, 0, 0, 316, 100, 1, 0, 0, 0, 11, 0, 166, 256, 263, 271, 274, 280, 282, 291, 302, 313, 1, 0, 1, 0] \ No newline at end of file diff --git a/alpha-core/src/main/gen/ASPLexer.java b/alpha-core/src/main/gen/ASPLexer.java deleted file mode 100644 index 0bd7f8452..000000000 --- a/alpha-core/src/main/gen/ASPLexer.java +++ /dev/null @@ -1,331 +0,0 @@ -// Generated from java-escape by ANTLR 4.11.1 -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.atn.*; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.*; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) -public class ASPLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.11.1", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ANONYMOUS_VARIABLE=1, DOT=2, COMMA=3, QUERY_MARK=4, COLON=5, SEMICOLON=6, - OR=7, NAF=8, CONS=9, WCONS=10, PLUS=11, MINUS=12, TIMES=13, DIV=14, POWER=15, - MODULO=16, BITXOR=17, AT=18, SHARP=19, AMPERSAND=20, QUOTE=21, PAREN_OPEN=22, - PAREN_CLOSE=23, SQUARE_OPEN=24, SQUARE_CLOSE=25, CURLY_OPEN=26, CURLY_CLOSE=27, - EQUAL=28, UNEQUAL=29, LESS=30, GREATER=31, LESS_OR_EQ=32, GREATER_OR_EQ=33, - AGGREGATE_COUNT=34, AGGREGATE_MAX=35, AGGREGATE_MIN=36, AGGREGATE_SUM=37, - DIRECTIVE_TEST=38, TEST_EXPECT=39, TEST_UNSAT=40, TEST_GIVEN=41, TEST_ASSERT_ALL=42, - TEST_ASSERT_SOME=43, ID=44, VARIABLE=45, NUMBER=46, QUOTED_STRING=47, - COMMENT=48, MULTI_LINE_COMMEN=49, BLANK=50; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; - - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - private static String[] makeRuleNames() { - return new String[] { - "ANONYMOUS_VARIABLE", "DOT", "COMMA", "QUERY_MARK", "COLON", "SEMICOLON", - "OR", "NAF", "CONS", "WCONS", "PLUS", "MINUS", "TIMES", "DIV", "POWER", - "MODULO", "BITXOR", "AT", "SHARP", "AMPERSAND", "QUOTE", "PAREN_OPEN", - "PAREN_CLOSE", "SQUARE_OPEN", "SQUARE_CLOSE", "CURLY_OPEN", "CURLY_CLOSE", - "EQUAL", "UNEQUAL", "LESS", "GREATER", "LESS_OR_EQ", "GREATER_OR_EQ", - "AGGREGATE_COUNT", "AGGREGATE_MAX", "AGGREGATE_MIN", "AGGREGATE_SUM", - "DIRECTIVE_TEST", "TEST_EXPECT", "TEST_UNSAT", "TEST_GIVEN", "TEST_ASSERT_ALL", - "TEST_ASSERT_SOME", "ID", "VARIABLE", "NUMBER", "QUOTED_STRING", "COMMENT", - "MULTI_LINE_COMMEN", "BLANK" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, "'_'", "'.'", "','", "'?'", "':'", "';'", "'|'", "'not'", "':-'", - "':~'", "'+'", "'-'", "'*'", "'/'", "'**'", "'\\'", "'^'", "'@'", "'#'", - "'&'", "'\"'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'='", null, - "'<'", "'>'", "'<='", "'>='", "'#count'", "'#max'", "'#min'", "'#sum'", - "'#test'", "'expect'", "'unsat'", "'given'", "'assertForAll'", "'assertForSome'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "ANONYMOUS_VARIABLE", "DOT", "COMMA", "QUERY_MARK", "COLON", "SEMICOLON", - "OR", "NAF", "CONS", "WCONS", "PLUS", "MINUS", "TIMES", "DIV", "POWER", - "MODULO", "BITXOR", "AT", "SHARP", "AMPERSAND", "QUOTE", "PAREN_OPEN", - "PAREN_CLOSE", "SQUARE_OPEN", "SQUARE_CLOSE", "CURLY_OPEN", "CURLY_CLOSE", - "EQUAL", "UNEQUAL", "LESS", "GREATER", "LESS_OR_EQ", "GREATER_OR_EQ", - "AGGREGATE_COUNT", "AGGREGATE_MAX", "AGGREGATE_MIN", "AGGREGATE_SUM", - "DIRECTIVE_TEST", "TEST_EXPECT", "TEST_UNSAT", "TEST_GIVEN", "TEST_ASSERT_ALL", - "TEST_ASSERT_SOME", "ID", "VARIABLE", "NUMBER", "QUOTED_STRING", "COMMENT", - "MULTI_LINE_COMMEN", "BLANK" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - public ASPLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - @Override - public String getGrammarFileName() { return "ASPLexer.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public String[] getChannelNames() { return channelNames; } - - @Override - public String[] getModeNames() { return modeNames; } - - @Override - public ATN getATN() { return _ATN; } - - public static final String _serializedATN = - "\u0004\u00002\u013d\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+ - "\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+ - "\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+ - "\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+ - "\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002"+ - "\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002"+ - "\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002"+ - "\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002"+ - "\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002"+ - "\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002"+ - "\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007"+ - "!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007"+ - "&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+ - "+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+ - "0\u00021\u00071\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+ - "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001"+ - "\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001"+ - "\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001"+ - "\n\u0001\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0001"+ - "\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010\u0001"+ - "\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ - "\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+ - "\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001"+ - "\u0019\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+ - "\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u00a7\b\u001c\u0001\u001d\u0001"+ - "\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ - " \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ - "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#"+ - "\u0001$\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001"+ - "%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001("+ - "\u0001(\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ - ")\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ - "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001"+ - "+\u0005+\u00ff\b+\n+\f+\u0102\t+\u0001,\u0001,\u0005,\u0106\b,\n,\f,\u0109"+ - "\t,\u0001-\u0001-\u0001-\u0005-\u010e\b-\n-\f-\u0111\t-\u0003-\u0113\b"+ - "-\u0001.\u0001.\u0001.\u0001.\u0005.\u0119\b.\n.\f.\u011c\t.\u0001.\u0001"+ - ".\u0001/\u0001/\u0005/\u0122\b/\n/\f/\u0125\t/\u0001/\u0001/\u00010\u0001"+ - "0\u00010\u00010\u00050\u012d\b0\n0\f0\u0130\t0\u00010\u00010\u00010\u0001"+ - "0\u00010\u00011\u00041\u0138\b1\u000b1\f1\u0139\u00011\u00011\u0002\u011a"+ - "\u012e\u00002\u0001\u0001\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005"+ - "\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019"+ - "\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012%\u0013\'\u0014)\u0015"+ - "+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c9\u001d;\u001e=\u001f"+ - "? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_0a1c2\u0001\u0000\u0003\u0004\u0000"+ - "09AZ__az\u0002\u0000\n\n\r\r\u0003\u0000\t\n\f\r \u0146\u0000\u0001\u0001"+ - "\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001"+ - "\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000"+ - "\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000"+ - "\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000"+ - "\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000"+ - "\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000"+ - "\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000"+ - "\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000"+ - "\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'"+ - "\u0001\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000"+ - "\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000"+ - "\u00001\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005"+ - "\u0001\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000"+ - "\u0000\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000"+ - "\u0000?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C"+ - "\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000"+ - "\u0000\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000"+ - "\u0000M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q"+ - "\u0001\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000"+ - "\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000"+ - "\u0000[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_"+ - "\u0001\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000"+ - "\u0000\u0000\u0001e\u0001\u0000\u0000\u0000\u0003g\u0001\u0000\u0000\u0000"+ - "\u0005i\u0001\u0000\u0000\u0000\u0007k\u0001\u0000\u0000\u0000\tm\u0001"+ - "\u0000\u0000\u0000\u000bo\u0001\u0000\u0000\u0000\rq\u0001\u0000\u0000"+ - "\u0000\u000fs\u0001\u0000\u0000\u0000\u0011w\u0001\u0000\u0000\u0000\u0013"+ - "z\u0001\u0000\u0000\u0000\u0015}\u0001\u0000\u0000\u0000\u0017\u007f\u0001"+ - "\u0000\u0000\u0000\u0019\u0081\u0001\u0000\u0000\u0000\u001b\u0083\u0001"+ - "\u0000\u0000\u0000\u001d\u0085\u0001\u0000\u0000\u0000\u001f\u0088\u0001"+ - "\u0000\u0000\u0000!\u008a\u0001\u0000\u0000\u0000#\u008c\u0001\u0000\u0000"+ - "\u0000%\u008e\u0001\u0000\u0000\u0000\'\u0090\u0001\u0000\u0000\u0000"+ - ")\u0092\u0001\u0000\u0000\u0000+\u0094\u0001\u0000\u0000\u0000-\u0096"+ - "\u0001\u0000\u0000\u0000/\u0098\u0001\u0000\u0000\u00001\u009a\u0001\u0000"+ - "\u0000\u00003\u009c\u0001\u0000\u0000\u00005\u009e\u0001\u0000\u0000\u0000"+ - "7\u00a0\u0001\u0000\u0000\u00009\u00a6\u0001\u0000\u0000\u0000;\u00a8"+ - "\u0001\u0000\u0000\u0000=\u00aa\u0001\u0000\u0000\u0000?\u00ac\u0001\u0000"+ - "\u0000\u0000A\u00af\u0001\u0000\u0000\u0000C\u00b2\u0001\u0000\u0000\u0000"+ - "E\u00b9\u0001\u0000\u0000\u0000G\u00be\u0001\u0000\u0000\u0000I\u00c3"+ - "\u0001\u0000\u0000\u0000K\u00c8\u0001\u0000\u0000\u0000M\u00ce\u0001\u0000"+ - "\u0000\u0000O\u00d5\u0001\u0000\u0000\u0000Q\u00db\u0001\u0000\u0000\u0000"+ - "S\u00e1\u0001\u0000\u0000\u0000U\u00ee\u0001\u0000\u0000\u0000W\u00fc"+ - "\u0001\u0000\u0000\u0000Y\u0103\u0001\u0000\u0000\u0000[\u0112\u0001\u0000"+ - "\u0000\u0000]\u0114\u0001\u0000\u0000\u0000_\u011f\u0001\u0000\u0000\u0000"+ - "a\u0128\u0001\u0000\u0000\u0000c\u0137\u0001\u0000\u0000\u0000ef\u0005"+ - "_\u0000\u0000f\u0002\u0001\u0000\u0000\u0000gh\u0005.\u0000\u0000h\u0004"+ - "\u0001\u0000\u0000\u0000ij\u0005,\u0000\u0000j\u0006\u0001\u0000\u0000"+ - "\u0000kl\u0005?\u0000\u0000l\b\u0001\u0000\u0000\u0000mn\u0005:\u0000"+ - "\u0000n\n\u0001\u0000\u0000\u0000op\u0005;\u0000\u0000p\f\u0001\u0000"+ - "\u0000\u0000qr\u0005|\u0000\u0000r\u000e\u0001\u0000\u0000\u0000st\u0005"+ - "n\u0000\u0000tu\u0005o\u0000\u0000uv\u0005t\u0000\u0000v\u0010\u0001\u0000"+ - "\u0000\u0000wx\u0005:\u0000\u0000xy\u0005-\u0000\u0000y\u0012\u0001\u0000"+ - "\u0000\u0000z{\u0005:\u0000\u0000{|\u0005~\u0000\u0000|\u0014\u0001\u0000"+ - "\u0000\u0000}~\u0005+\u0000\u0000~\u0016\u0001\u0000\u0000\u0000\u007f"+ - "\u0080\u0005-\u0000\u0000\u0080\u0018\u0001\u0000\u0000\u0000\u0081\u0082"+ - "\u0005*\u0000\u0000\u0082\u001a\u0001\u0000\u0000\u0000\u0083\u0084\u0005"+ - "/\u0000\u0000\u0084\u001c\u0001\u0000\u0000\u0000\u0085\u0086\u0005*\u0000"+ - "\u0000\u0086\u0087\u0005*\u0000\u0000\u0087\u001e\u0001\u0000\u0000\u0000"+ - "\u0088\u0089\u0005\\\u0000\u0000\u0089 \u0001\u0000\u0000\u0000\u008a"+ - "\u008b\u0005^\u0000\u0000\u008b\"\u0001\u0000\u0000\u0000\u008c\u008d"+ - "\u0005@\u0000\u0000\u008d$\u0001\u0000\u0000\u0000\u008e\u008f\u0005#"+ - "\u0000\u0000\u008f&\u0001\u0000\u0000\u0000\u0090\u0091\u0005&\u0000\u0000"+ - "\u0091(\u0001\u0000\u0000\u0000\u0092\u0093\u0005\"\u0000\u0000\u0093"+ - "*\u0001\u0000\u0000\u0000\u0094\u0095\u0005(\u0000\u0000\u0095,\u0001"+ - "\u0000\u0000\u0000\u0096\u0097\u0005)\u0000\u0000\u0097.\u0001\u0000\u0000"+ - "\u0000\u0098\u0099\u0005[\u0000\u0000\u00990\u0001\u0000\u0000\u0000\u009a"+ - "\u009b\u0005]\u0000\u0000\u009b2\u0001\u0000\u0000\u0000\u009c\u009d\u0005"+ - "{\u0000\u0000\u009d4\u0001\u0000\u0000\u0000\u009e\u009f\u0005}\u0000"+ - "\u0000\u009f6\u0001\u0000\u0000\u0000\u00a0\u00a1\u0005=\u0000\u0000\u00a1"+ - "8\u0001\u0000\u0000\u0000\u00a2\u00a3\u0005<\u0000\u0000\u00a3\u00a7\u0005"+ - ">\u0000\u0000\u00a4\u00a5\u0005!\u0000\u0000\u00a5\u00a7\u0005=\u0000"+ - "\u0000\u00a6\u00a2\u0001\u0000\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000"+ - "\u0000\u00a7:\u0001\u0000\u0000\u0000\u00a8\u00a9\u0005<\u0000\u0000\u00a9"+ - "<\u0001\u0000\u0000\u0000\u00aa\u00ab\u0005>\u0000\u0000\u00ab>\u0001"+ - "\u0000\u0000\u0000\u00ac\u00ad\u0005<\u0000\u0000\u00ad\u00ae\u0005=\u0000"+ - "\u0000\u00ae@\u0001\u0000\u0000\u0000\u00af\u00b0\u0005>\u0000\u0000\u00b0"+ - "\u00b1\u0005=\u0000\u0000\u00b1B\u0001\u0000\u0000\u0000\u00b2\u00b3\u0005"+ - "#\u0000\u0000\u00b3\u00b4\u0005c\u0000\u0000\u00b4\u00b5\u0005o\u0000"+ - "\u0000\u00b5\u00b6\u0005u\u0000\u0000\u00b6\u00b7\u0005n\u0000\u0000\u00b7"+ - "\u00b8\u0005t\u0000\u0000\u00b8D\u0001\u0000\u0000\u0000\u00b9\u00ba\u0005"+ - "#\u0000\u0000\u00ba\u00bb\u0005m\u0000\u0000\u00bb\u00bc\u0005a\u0000"+ - "\u0000\u00bc\u00bd\u0005x\u0000\u0000\u00bdF\u0001\u0000\u0000\u0000\u00be"+ - "\u00bf\u0005#\u0000\u0000\u00bf\u00c0\u0005m\u0000\u0000\u00c0\u00c1\u0005"+ - "i\u0000\u0000\u00c1\u00c2\u0005n\u0000\u0000\u00c2H\u0001\u0000\u0000"+ - "\u0000\u00c3\u00c4\u0005#\u0000\u0000\u00c4\u00c5\u0005s\u0000\u0000\u00c5"+ - "\u00c6\u0005u\u0000\u0000\u00c6\u00c7\u0005m\u0000\u0000\u00c7J\u0001"+ - "\u0000\u0000\u0000\u00c8\u00c9\u0005#\u0000\u0000\u00c9\u00ca\u0005t\u0000"+ - "\u0000\u00ca\u00cb\u0005e\u0000\u0000\u00cb\u00cc\u0005s\u0000\u0000\u00cc"+ - "\u00cd\u0005t\u0000\u0000\u00cdL\u0001\u0000\u0000\u0000\u00ce\u00cf\u0005"+ - "e\u0000\u0000\u00cf\u00d0\u0005x\u0000\u0000\u00d0\u00d1\u0005p\u0000"+ - "\u0000\u00d1\u00d2\u0005e\u0000\u0000\u00d2\u00d3\u0005c\u0000\u0000\u00d3"+ - "\u00d4\u0005t\u0000\u0000\u00d4N\u0001\u0000\u0000\u0000\u00d5\u00d6\u0005"+ - "u\u0000\u0000\u00d6\u00d7\u0005n\u0000\u0000\u00d7\u00d8\u0005s\u0000"+ - "\u0000\u00d8\u00d9\u0005a\u0000\u0000\u00d9\u00da\u0005t\u0000\u0000\u00da"+ - "P\u0001\u0000\u0000\u0000\u00db\u00dc\u0005g\u0000\u0000\u00dc\u00dd\u0005"+ - "i\u0000\u0000\u00dd\u00de\u0005v\u0000\u0000\u00de\u00df\u0005e\u0000"+ - "\u0000\u00df\u00e0\u0005n\u0000\u0000\u00e0R\u0001\u0000\u0000\u0000\u00e1"+ - "\u00e2\u0005a\u0000\u0000\u00e2\u00e3\u0005s\u0000\u0000\u00e3\u00e4\u0005"+ - "s\u0000\u0000\u00e4\u00e5\u0005e\u0000\u0000\u00e5\u00e6\u0005r\u0000"+ - "\u0000\u00e6\u00e7\u0005t\u0000\u0000\u00e7\u00e8\u0005F\u0000\u0000\u00e8"+ - "\u00e9\u0005o\u0000\u0000\u00e9\u00ea\u0005r\u0000\u0000\u00ea\u00eb\u0005"+ - "A\u0000\u0000\u00eb\u00ec\u0005l\u0000\u0000\u00ec\u00ed\u0005l\u0000"+ - "\u0000\u00edT\u0001\u0000\u0000\u0000\u00ee\u00ef\u0005a\u0000\u0000\u00ef"+ - "\u00f0\u0005s\u0000\u0000\u00f0\u00f1\u0005s\u0000\u0000\u00f1\u00f2\u0005"+ - "e\u0000\u0000\u00f2\u00f3\u0005r\u0000\u0000\u00f3\u00f4\u0005t\u0000"+ - "\u0000\u00f4\u00f5\u0005F\u0000\u0000\u00f5\u00f6\u0005o\u0000\u0000\u00f6"+ - "\u00f7\u0005r\u0000\u0000\u00f7\u00f8\u0005S\u0000\u0000\u00f8\u00f9\u0005"+ - "o\u0000\u0000\u00f9\u00fa\u0005m\u0000\u0000\u00fa\u00fb\u0005e\u0000"+ - "\u0000\u00fbV\u0001\u0000\u0000\u0000\u00fc\u0100\u0002az\u0000\u00fd"+ - "\u00ff\u0007\u0000\u0000\u0000\u00fe\u00fd\u0001\u0000\u0000\u0000\u00ff"+ - "\u0102\u0001\u0000\u0000\u0000\u0100\u00fe\u0001\u0000\u0000\u0000\u0100"+ - "\u0101\u0001\u0000\u0000\u0000\u0101X\u0001\u0000\u0000\u0000\u0102\u0100"+ - "\u0001\u0000\u0000\u0000\u0103\u0107\u0002AZ\u0000\u0104\u0106\u0007\u0000"+ - "\u0000\u0000\u0105\u0104\u0001\u0000\u0000\u0000\u0106\u0109\u0001\u0000"+ - "\u0000\u0000\u0107\u0105\u0001\u0000\u0000\u0000\u0107\u0108\u0001\u0000"+ - "\u0000\u0000\u0108Z\u0001\u0000\u0000\u0000\u0109\u0107\u0001\u0000\u0000"+ - "\u0000\u010a\u0113\u00050\u0000\u0000\u010b\u010f\u000219\u0000\u010c"+ - "\u010e\u000209\u0000\u010d\u010c\u0001\u0000\u0000\u0000\u010e\u0111\u0001"+ - "\u0000\u0000\u0000\u010f\u010d\u0001\u0000\u0000\u0000\u010f\u0110\u0001"+ - "\u0000\u0000\u0000\u0110\u0113\u0001\u0000\u0000\u0000\u0111\u010f\u0001"+ - "\u0000\u0000\u0000\u0112\u010a\u0001\u0000\u0000\u0000\u0112\u010b\u0001"+ - "\u0000\u0000\u0000\u0113\\\u0001\u0000\u0000\u0000\u0114\u011a\u0003)"+ - "\u0014\u0000\u0115\u0116\u0005\\\u0000\u0000\u0116\u0119\u0005\"\u0000"+ - "\u0000\u0117\u0119\t\u0000\u0000\u0000\u0118\u0115\u0001\u0000\u0000\u0000"+ - "\u0118\u0117\u0001\u0000\u0000\u0000\u0119\u011c\u0001\u0000\u0000\u0000"+ - "\u011a\u011b\u0001\u0000\u0000\u0000\u011a\u0118\u0001\u0000\u0000\u0000"+ - "\u011b\u011d\u0001\u0000\u0000\u0000\u011c\u011a\u0001\u0000\u0000\u0000"+ - "\u011d\u011e\u0003)\u0014\u0000\u011e^\u0001\u0000\u0000\u0000\u011f\u0123"+ - "\u0005%\u0000\u0000\u0120\u0122\b\u0001\u0000\u0000\u0121\u0120\u0001"+ - "\u0000\u0000\u0000\u0122\u0125\u0001\u0000\u0000\u0000\u0123\u0121\u0001"+ - "\u0000\u0000\u0000\u0123\u0124\u0001\u0000\u0000\u0000\u0124\u0126\u0001"+ - "\u0000\u0000\u0000\u0125\u0123\u0001\u0000\u0000\u0000\u0126\u0127\u0006"+ - "/\u0000\u0000\u0127`\u0001\u0000\u0000\u0000\u0128\u0129\u0005%\u0000"+ - "\u0000\u0129\u012a\u0005*\u0000\u0000\u012a\u012e\u0001\u0000\u0000\u0000"+ - "\u012b\u012d\t\u0000\u0000\u0000\u012c\u012b\u0001\u0000\u0000\u0000\u012d"+ - "\u0130\u0001\u0000\u0000\u0000\u012e\u012f\u0001\u0000\u0000\u0000\u012e"+ - "\u012c\u0001\u0000\u0000\u0000\u012f\u0131\u0001\u0000\u0000\u0000\u0130"+ - "\u012e\u0001\u0000\u0000\u0000\u0131\u0132\u0005*\u0000\u0000\u0132\u0133"+ - "\u0005%\u0000\u0000\u0133\u0134\u0001\u0000\u0000\u0000\u0134\u0135\u0006"+ - "0\u0000\u0000\u0135b\u0001\u0000\u0000\u0000\u0136\u0138\u0007\u0002\u0000"+ - "\u0000\u0137\u0136\u0001\u0000\u0000\u0000\u0138\u0139\u0001\u0000\u0000"+ - "\u0000\u0139\u0137\u0001\u0000\u0000\u0000\u0139\u013a\u0001\u0000\u0000"+ - "\u0000\u013a\u013b\u0001\u0000\u0000\u0000\u013b\u013c\u00061\u0000\u0000"+ - "\u013cd\u0001\u0000\u0000\u0000\u000b\u0000\u00a6\u0100\u0107\u010f\u0112"+ - "\u0118\u011a\u0123\u012e\u0139\u0001\u0000\u0001\u0000"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file From c7b1f9ad26b5aae4f3643b1c693f85361aba80d0 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 5 Mar 2023 14:15:24 +0100 Subject: [PATCH 82/96] allow keywords as identifiers in programs --- .../commons/util/TestExecutionException.java | 13 -------- .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 16 +++++----- .../ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 | 4 ++- .../alpha/core/parser/ParseTreeVisitor.java | 31 ++++++++++++------- .../kr/alpha/core/parser/ParserTest.java | 14 +++++++++ 5 files changed, 45 insertions(+), 33 deletions(-) delete mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java deleted file mode 100644 index 43ee3845f..000000000 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/util/TestExecutionException.java +++ /dev/null @@ -1,13 +0,0 @@ -package at.ac.tuwien.kr.alpha.commons.util; - -public class TestExecutionException extends Exception { - - public TestExecutionException(String msg) { - super(msg); - } - - public TestExecutionException(String msg, Throwable t) { - super(msg, t); - } - -} diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index ef1565fd0..4c70359fb 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -46,7 +46,9 @@ naf_literals : naf_literal (COMMA naf_literals)?; naf_literal : NAF? (external_atom | classical_literal | builtin_atom); -basic_atom : ID (PAREN_OPEN terms PAREN_CLOSE)?; +id : ID | TEST_EXPECT | TEST_UNSAT | TEST_GIVEN | TEST_ASSERT_ALL | TEST_ASSERT_SOME | DIRECTIVE_ENUM | DIRECTIVE_TEST; + +basic_atom : id (PAREN_OPEN terms PAREN_CLOSE)?; classical_literal : MINUS? basic_atom; @@ -56,8 +58,8 @@ binop : EQUAL | UNEQUAL | LESS | GREATER | LESS_OR_EQ | GREATER_OR_EQ; terms : term (COMMA terms)?; -term : ID # term_const - | ID (PAREN_OPEN terms? PAREN_CLOSE) # term_func +term : id # term_const + | id (PAREN_OPEN terms? PAREN_CLOSE) # term_func | numeral # term_number | QUOTED_STRING # term_string | VARIABLE # term_variable @@ -77,21 +79,21 @@ interval : lower = interval_bound DOT DOT upper = interval_bound; // NOT Core2 s interval_bound : numeral | VARIABLE; -external_atom : MINUS? AMPERSAND ID (SQUARE_OPEN input = terms SQUARE_CLOSE)? (PAREN_OPEN output = terms PAREN_CLOSE)?; // NOT Core2 syntax. +external_atom : MINUS? AMPERSAND id (SQUARE_OPEN input = terms SQUARE_CLOSE)? (PAREN_OPEN output = terms PAREN_CLOSE)?; // NOT Core2 syntax. directive : directive_enumeration | directive_test; // NOT Core2 syntax, allows solver specific directives. Further directives shall be added here. -directive_enumeration : SHARP 'enumeration_predicate_is' ID DOT; // NOT Core2 syntax, used for aggregate translation. +directive_enumeration : SHARP DIRECTIVE_ENUM id DOT; // NOT Core2 syntax, used for aggregate translation. // TODO change lexer rules s.t. test-specific keywords can still be used as IDs! // Alpha-specific language extension: Unit Tests (-> https://github.com/alpha-asp/Alpha/issues/237) -directive_test : DIRECTIVE_TEST ID PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; +directive_test : SHARP DIRECTIVE_TEST id PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; basic_terms : basic_term (COMMA basic_terms)? ; basic_term : ground_term | variable_term; -ground_term : /*SYMBOLIC_CONSTANT*/ ID | QUOTED_STRING | numeral; +ground_term : /*SYMBOLIC_CONSTANT*/ id | QUOTED_STRING | numeral; variable_term : VARIABLE | ANONYMOUS_VARIABLE; diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 index 83cdff8e4..1e5582d82 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPLexer.g4 @@ -40,7 +40,9 @@ AGGREGATE_MAX : '#max'; AGGREGATE_MIN : '#min'; AGGREGATE_SUM : '#sum'; -DIRECTIVE_TEST : '#test'; +DIRECTIVE_ENUM : 'enumeration_predicate_is'; + +DIRECTIVE_TEST : 'test'; TEST_EXPECT : 'expect'; TEST_UNSAT : 'unsat'; TEST_GIVEN : 'given'; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index a1c1b4709..b9e2cc758 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -286,14 +286,15 @@ public List visitNaf_literals(ASPCore2Parser.Naf_literalsContext ctx) { @Override public Object visitDirective_enumeration(ASPCore2Parser.Directive_enumerationContext ctx) { - // directive_enumeration : SHARP 'enum_predicate_is' ID DOT; - inlineDirectives.addDirective(InlineDirectives.DIRECTIVE.enum_predicate_is, ctx.ID().getText()); + // directive_enumeration : DIRECTIVE_ENUM id DOT; + inlineDirectives.addDirective(InlineDirectives.DIRECTIVE.enum_predicate_is, visitId(ctx.id())); return null; } @Override public Object visitDirective_test(ASPCore2Parser.Directive_testContext ctx) { - String name = ctx.ID().getText(); + // directive_test : DIRECTIVE_TEST id PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; + String name = visitId(ctx.id()); IntPredicate answerSetCountVerifier = visitTest_satisfiability_condition(ctx.test_satisfiability_condition()); Set input = visitTest_input(ctx.test_input()); List assertions; @@ -393,10 +394,10 @@ public Term visitBasic_term(ASPCore2Parser.Basic_termContext ctx) { @Override public Term visitGround_term(ASPCore2Parser.Ground_termContext ctx) { - // ground_term : ID | QUOTED_STRING | numeral; - if (ctx.ID() != null) { - // ID - return Terms.newSymbolicConstant(ctx.ID().getText()); + // ground_term : id | QUOTED_STRING | numeral; + if (ctx.id() != null) { + // id + return Terms.newSymbolicConstant(visitId(ctx.id())); } else if (ctx.QUOTED_STRING() != null) { // QUOTED_STRING String quotedString = ctx.QUOTED_STRING().getText(); @@ -476,11 +477,17 @@ public Literal visitNaf_literal(ASPCore2Parser.Naf_literalContext ctx) { throw notSupported(ctx); } + @Override + public String visitId(ASPCore2Parser.IdContext ctx) { + // id : ID | TEST_EXPECT | TEST_UNSAT | TEST_GIVEN | TEST_ASSERT_ALL | TEST_ASSERT_SOME; + return ctx.getText(); + } + @Override public BasicAtom visitBasic_atom(ASPCore2Parser.Basic_atomContext ctx) { // basic_atom : ID (PAREN_OPEN terms PAREN_CLOSE)?; List terms = visitTerms(ctx.terms()); - return Atoms.newBasicAtom(Predicates.getPredicate(ctx.ID().getText(), terms.size()), terms); + return Atoms.newBasicAtom(Predicates.getPredicate(visitId(ctx.id()), terms.size()), terms); } @Override @@ -522,7 +529,7 @@ public Integer visitNumeral(ASPCore2Parser.NumeralContext ctx) { @Override public ConstantTerm visitTerm_const(ASPCore2Parser.Term_constContext ctx) { - return Terms.newSymbolicConstant(ctx.ID().getText()); + return Terms.newSymbolicConstant(visitId(ctx.id())); } @Override @@ -533,7 +540,7 @@ public ConstantTerm visitTerm_string(ASPCore2Parser.Term_stringContext c @Override public FunctionTerm visitTerm_func(ASPCore2Parser.Term_funcContext ctx) { - return Terms.newFunctionTerm(ctx.ID().getText(), visitTerms(ctx.terms())); + return Terms.newFunctionTerm(visitId(ctx.id()), visitTerms(ctx.terms())); } @Override @@ -559,13 +566,13 @@ public Term visitTerm_parenthesisedTerm(ASPCore2Parser.Term_parenthesisedTermCon @Override public ExternalAtom visitExternal_atom(ASPCore2Parser.External_atomContext ctx) { - // external_atom : AMPERSAND ID (SQUARE_OPEN input = terms SQUARE_CLOSE)? (PAREN_OPEN output = terms PAREN_CLOSE)?; + // external_atom : AMPERSAND id (SQUARE_OPEN input = terms SQUARE_CLOSE)? (PAREN_OPEN output = terms PAREN_CLOSE)?; if (ctx.MINUS() != null) { throw notSupported(ctx); } - final String predicateName = ctx.ID().getText(); + final String predicateName = visitId(ctx.id()); final PredicateInterpretation interpretation = externals.get(predicateName); if (interpretation == null) { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 3a9593c74..3c4da3aaa 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -84,6 +84,9 @@ public class ParserTest { "a :- b. #test ensure_a(expect: 1) { given { b. } assertForAll { :- not a. }} " + "#test ensure_not_c (expect: 1) { given { b.} assertForAll { :- c. }}"; + private static final String UNIT_TEST_KEYWORDS_AS_IDS = + "assert(a) :- given(b). # test test(expect: 1) { given { given(b). } assertForAll { :- not assert(a). :- assertForSome(b).}}"; + private final ProgramParserImpl parser = new ProgramParserImpl(); @Test @@ -291,4 +294,15 @@ public void unitTestMoreTCs() { assertEquals("ensure_not_c", tc2.getName()); } + @Test + public void unitTestKeywordsAsIds() { + ASPCore2Program prog = parser.parse(UNIT_TEST_KEYWORDS_AS_IDS); + assertEquals(1, prog.getTestCases().size()); + TestCase tc = prog.getTestCases().get(0); + assertEquals("test", tc.getName()); + assertEquals(1, tc.getInput().size()); + assertEquals(1, tc.getAssertions().size()); + assertEquals(Assertion.Mode.FOR_ALL, tc.getAssertions().get(0).getMode()); + } + } From 5dd8f80523ac92475047f132b2091f67e143a5a3 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 5 Mar 2023 16:02:26 +0100 Subject: [PATCH 83/96] remove obsolete TODO --- .../src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 1 - 1 file changed, 1 deletion(-) diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index 4c70359fb..44039084e 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -85,7 +85,6 @@ directive : directive_enumeration | directive_test; // NOT Core2 syntax, allows directive_enumeration : SHARP DIRECTIVE_ENUM id DOT; // NOT Core2 syntax, used for aggregate translation. -// TODO change lexer rules s.t. test-specific keywords can still be used as IDs! // Alpha-specific language extension: Unit Tests (-> https://github.com/alpha-asp/Alpha/issues/237) directive_test : SHARP DIRECTIVE_TEST id PAREN_OPEN test_satisfiability_condition PAREN_CLOSE CURLY_OPEN test_input test_assert* CURLY_CLOSE; From e9dccb7cafdde7bcaa9469bd4569cd7a9755a0fa Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 28 Apr 2023 14:04:52 +0200 Subject: [PATCH 84/96] Make releasing Alpha more convenient by adding gradle release plugin (#359) --- README.md | 12 ++++----- RELEASE.md | 70 ++++++++++++++++++++++++++---------------------- build.gradle.kts | 13 +++++++++ 3 files changed, 57 insertions(+), 38 deletions(-) diff --git a/README.md b/README.md index 6e5147a2c..0c3bb9412 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ possibilities to interface with the ecosystem built around the Java Virtual Mach ## Getting Started -Download a current version of `alpha.jar` from [Releases](https://github.com/alpha-asp/Alpha/releases). +Download a current version of the distribution jar (`alpha-cli-app-${version}-bundled.jar`) from [Releases](https://github.com/alpha-asp/Alpha/releases) and save it as `alpha.jar` for convenience. Running Alpha is as simple as running any other JAR: @@ -52,19 +52,19 @@ Alpha uses the [Gradle build automation system](https://gradle.org). Executing $ ./gradlew build ``` -will automatically fetch all dependencies (declared in [`build.gradle`](build.gradle)) and compile the project. +will automatically fetch all dependencies (declared in [`build.gradle.kts`](build.gradle.kts)) and compile the project. -Artifacts generated will be placed in `build/`. Most notably you'll find files ready for distribution at -`build/distributions/`. They contain archives which in turn contain a `bin/` directory with scripts to run Alpha on Linux +Artifacts generated will be placed in the `build/` subfolder of the respective module. Most notably you'll find files ready for distribution at +`alpha-cli-app/build/distributions/`. They contain archives which in turn contain a `bin/` directory with scripts to run Alpha on Linux and Windows. If you want to generate a JAR file to be run standalone, execute ```bash -$ ./gradlew bundledJar +$ ./gradlew alpha-cli-app:bundledJar ``` -and pick up `build/libs/alpha-bundled.jar`. +and pick up `alpha-cli-app/build/libs/alpha-cli-app-${version}-bundled.jar`. ### A Note on IDEs diff --git a/RELEASE.md b/RELEASE.md index 400d3cff6..5d922b0b6 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -2,64 +2,70 @@ This document explains how to build and release Alpha. -First, decide which revision (= Git commit) of Alpha you want to release. This revision should be on `master` -and ideally ahead of any previously released revisions. We denote the Git commit hash of the revision to be -released as `$rev` (it is a reference to a commit, so it could be the name of a branch, say, `master` or just -a hash like `cafebabe`). - -You probably have already checked out this version, but if you haven't, do so now: +The regular release workflow for Alpha assumes that a release will always be based on the latest commit in the `master` branch. In order to release Alpha, first checkout the `master` branch and make sure you're up to date: ```bash -$ git checkout $rev +$ git checkout master +$ git pull ``` -Now is the time to make sure the revision you are about to release actually works fine. Run tests, try it out -manually, maybe go paranoid and `./gradlew clean` everything and try again. Only continue if you are happy with -the revision you are about to release, and avoid list minute fixes. +Now is the time to make sure the revision you are about to release actually works. Build it using `./gradlew clean build`, potentially do some manual tests, play around a bit, maybe go paranoid and `./gradlew clean build` everything once more. Only continue if you are happy with the state you are about to release, and avoid last minute fixes. -Next, give `$rev` a name, by tagging it. The naming convention for tags is -[Semantic Versioning 2](http://semver.org/spec/v2.0.0.html). **Read through the specification of Semantic -Versioning carefully, before releasing anything. If in doubt, read it again and seek advice.** +The actual release process consists of following steps: +- Create a release tag using gradle release plugin. +- From the tag created by gradle release plugin, create a release on github. -Make sure the version you want to release does not collide and fits with any -[tags already present on GitHub](https://github.com/alpha-asp/Alpha/tags). We denote the version to be released -as `$version` (it looks like "v0.1.0", "v1.0.0-beta", note it starts with the letter "v"). +#### Creating a release tag using Gradle Release Plugin -```bash -$ git tag $version -``` +Before running the release plugin, decide on a release version identifier and the next development version. Version identifiers must confirm to [Semantic Versioning 2](http://semver.org/spec/v2.0.0.html). **Read through the specification of Semantic Versioning carefully, before releasing anything. If in doubt, read it again and seek advice.** Also, make sure the version you want to release does not collide with any [tag already present on GitHub](https://github.com/alpha-asp/Alpha/tags). We denote the version to be released as `$version` (it looks like "0.1.0", "1.0.0-beta"). -Now you push this tag to GitHub: +The next development version (denoted `$nextVersion`) is the version you expect to be the next release version. Note that it isn't set in stone since actual release versions are set during the release process. For example, if your release version is `0.9.0`, your next version could be `0.10.0` or `1.0.0`. + +To create a release tag and set the correct versions in the `gradle.properties` file, call the gradle release plugin: ```bash -$ git push --tags +$ ./gradlew release -Prelease.useAutomaticVersion=true -Prelease.releaseVersion=$version -Prelease.newVersion=$nextVersion-SNAPSHOT ``` +**Make sure you add the `-SNAPSHOT` qualifier to the next version!** This is the version that will be put into `gradle.properties` in the `master` branch after creating the release tag, i.e. subsequent builds of `master` (e.g. nightly builds from CI workflows) will have this version. + +The release plugin automatically pushes all changes it makes in the repository. After running it, make sure: +- `gradle.properties` in `master` has the new `SNAPSHOT` version. +- On github, you can see a new tag with the same name as your release version. +- When you check out the tag, `gradle.properties` contains the correct version, i.e. the tag name. Navigate to (Releases)[https://github.com/alpha-asp/Alpha/releases] and press "Draft a new release"). Fill in `$version` as the name of your tag, and change the Release Title to `$version`. Feel free to write a release note (we currently have no policy in place for release notes). If `$version` is below 1 or you are releasing a preview version, check the box. -Now, let's generate two distribution packages of Alpha for convenience. You will attach two files to the release on -GitHub. `alpha.jar`, a self-contained and executbale JAR and `alpha.zip` which contains Alpha as JAR file, dependencies -as JAR files and two scripts to run Alpha on Unix-like and Windows respectively. +Now, let's generate some distribution packages of Alpha for convenience. You will attach the following files to the release on GitHub: +- `alpha-cli-app-$version-bundled.jar: A "fat-jar" containingthe Alpha CLI applications along with all dependencies in one jar file. +- Distribution zip- and tar-archives for the CLI application: Zip- and tar-versions of an archive with Alpha, all dependencies, and launcher scripts for windows and UNIX-like systems. +- A zip- and tar-archive of the source code for Alpha. -To generate `alpha.jar`: +To generate these artifacts, check out your release tag: + +```bash +$ git checkout $version +``` + +To generate the "fat-jar": ```bash $ ./gradlew alpha-cli-app:bundledJar -$ cp alpha-cli-app/build/libs/alpha-cli*-bundled.jar alpha.jar ``` -To generate `alpha.zip`: +The jar file can be found in `./alpha-cli-app/build/libs/alpha-cli-app-$version-bundled.jar` + +To generate distribution archives: ```bash -$ ./gradlew alpha-cli-app:distZip -$ cp alpha-cli-app/build/distributions/*.zip alpha.zip +$ ./gradlew alpha-cli-app:distZip && ./gradlew alpha-cli-app:distTar ``` -Attach the two files to the release on GitHub, then publish the release. Lastly, check that everything is fine, -e.g. that the tag/version really points at the revision you wanted to rlease and that `alpha.zip` and `alpha.jar -downloaded from GitHub do what they are supposed to do. +The finished archives are located in `./alpha-cli-app/build/distributions/`. +Last `./gradlew clean` the project to get rid of all build artifacts, then create a `sources.zip` (using e.g. `zip -r sources.zip .`) and a `sources.tar.gz` (using e.g. `tar -czf /tmp/sources.tar.gz .`) + +Attach the generated files to the release on GitHub, then publish the release. Last but not least, check that everything is fine, i.e. the files - when downloaded from the github release - do what they're supposed to. Optionally, archive the release on Zenodo. If you do so, add the new identifier to `CITATION.cff`. diff --git a/build.gradle.kts b/build.gradle.kts index 9ada3d89e..4cff4f84b 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,7 +1,10 @@ +import net.researchgate.release.ReleaseExtension + plugins { jacoco id("com.github.kt3k.coveralls") version "2.12.0" id("jacoco-report-aggregation") + id("net.researchgate.release") version "3.0.2" } tasks.wrapper { @@ -22,5 +25,15 @@ reporting { } repositories { + maven ("https://plugins.gradle.org/m2/") mavenCentral { metadataSources { mavenPom() } } +} + +configure { + failOnUnversionedFiles.set(true) + // Tag template currently doesn't work with non-interactive release, see https://github.com/researchgate/gradle-release/issues/371 + // tagTemplate.set("v${version}") + with(git) { + requireBranch.set("master") + } } \ No newline at end of file From ef74c9cb94af896d71f44cff1e46269171d3ce19 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 28 Apr 2023 14:50:59 +0200 Subject: [PATCH 85/96] [Gradle Release Plugin] - pre tag commit: '0.7.0'. --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 79a8403fc..98c6b5806 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,3 +1,3 @@ -version=0.7.0-SNAPSHOT +version=0.7.0 group=at.ac.tuwien.kr.alpha org.gradle.warning.mode=all From 2cce4364948dfcc3f18f4b2cf6509ace9acb62be Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 28 Apr 2023 14:51:01 +0200 Subject: [PATCH 86/96] [Gradle Release Plugin] - new version commit: '0.8.0-SNAPSHOT'. --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 98c6b5806..94628898d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,3 +1,3 @@ -version=0.7.0 +version=0.8.0-SNAPSHOT group=at.ac.tuwien.kr.alpha org.gradle.warning.mode=all From 6512eeace8bcdfc071e4551e773e4c6427155ae2 Mon Sep 17 00:00:00 2001 From: AntoniusWeinzierl Date: Mon, 24 Jul 2023 19:20:52 +0200 Subject: [PATCH 87/96] Update dependencies to avoid several CVEs. - Make dependency on commons-compress explicit to pull-in newer version. - Make dependency on Guava explicit as it no longer is transitively included. --- .../main/kotlin/alpha.java-common-conventions.gradle.kts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts index 9d59cf165..69fe7a74a 100644 --- a/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/alpha.java-common-conventions.gradle.kts @@ -17,10 +17,12 @@ java.targetCompatibility = JavaVersion.VERSION_11 dependencies { implementation("org.apache.commons:commons-collections4:4.4") + implementation("org.apache.commons:commons-compress:1.23.0") // Explicitly depend on newer version than pulled-in by commons-lang3:3.12.0 to avoid several CVEs (cf. issue #362) implementation("org.apache.commons:commons-lang3:3.12.0") - implementation("org.apache.commons:commons-text:1.9") + implementation("org.apache.commons:commons-text:1.10.0") - implementation("org.reflections:reflections:0.9.11") + implementation("org.reflections:reflections:0.10.2") + implementation("com.google.guava:guava:32.1.1-jre") implementation("org.slf4j:slf4j-api:1.7.32") // JUnit 5 From 782c338ddd859cbbb2084054ac3a820ac737954f Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Fri, 1 Dec 2023 15:14:44 +0100 Subject: [PATCH 88/96] fix ParserTest - use updated type name InputProgram instead of ASPCore2Program --- .../test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 05f88a7b1..f900a5047 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -198,7 +198,7 @@ public void testMissingDotNotIgnored() { @Test public void parseEnumerationDirective() { - ASPCore2Program parsedProgram = parser.parse("p(a,1)." + + InputProgram parsedProgram = parser.parse("p(a,1)." + "# enumeration_predicate_is mune." + "r(X) :- p(X), mune(X)." + "p(b,2)."); From c7ec4939b0f8837714fcb58be6706ea01c089962 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 10 Dec 2023 19:40:53 +0100 Subject: [PATCH 89/96] fix FunctionTermImpl#equals s.t. also subtypes can be equal --- .../commons/rules/heads/ActionHeadImpl.java | 5 ++++ .../alpha/commons/terms/FunctionTermImpl.java | 23 +++++++++++-------- .../kr/alpha/commons/terms/TermsTest.java | 12 ++++++++++ .../core/grounder/IndexedInstanceStorage.java | 3 ++- 4 files changed, 32 insertions(+), 11 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java index f64ca535b..dd1d5ee3d 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/rules/heads/ActionHeadImpl.java @@ -9,6 +9,7 @@ import at.ac.tuwien.kr.alpha.api.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.terms.Term; import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; +import org.apache.commons.lang3.StringUtils; class ActionHeadImpl implements ActionHead { @@ -55,4 +56,8 @@ public VariableTerm getActionOutputTerm() { return actionOutputTerm; } + public String toString() { + return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; + } + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java index 694905e48..a5d605cc8 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/FunctionTermImpl.java @@ -98,16 +98,19 @@ public boolean equals(Object o) { if (this == o) { return true; } - if (o == null || getClass() != o.getClass()) { + if (o == null) { + return false; + } + if (!(o instanceof FunctionTerm)) { return false; } - FunctionTermImpl that = (FunctionTermImpl) o; + FunctionTerm that = (FunctionTerm) o; - if (!symbol.equals(that.symbol)) { + if (!symbol.equals(that.getSymbol())) { return false; } - return terms.equals(that.terms); + return terms.equals(that.getTerms()); } @Override @@ -121,24 +124,24 @@ public int compareTo(Term o) { return 0; } - if (!(o instanceof FunctionTermImpl)) { + if (!(o instanceof FunctionTerm)) { return super.compareTo(o); } - FunctionTermImpl other = (FunctionTermImpl) o; + FunctionTerm other = (FunctionTerm) o; - if (terms.size() != other.terms.size()) { - return terms.size() - other.terms.size(); + if (terms.size() != other.getTerms().size()) { + return terms.size() - other.getTerms().size(); } - int result = symbol.compareTo(other.symbol); + int result = symbol.compareTo(other.getSymbol()); if (result != 0) { return result; } for (int i = 0; i < terms.size(); i++) { - result = terms.get(i).compareTo(other.terms.get(i)); + result = terms.get(i).compareTo(other.getTerms().get(i)); if (result != 0) { return result; } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java index 4c4600dc8..cf361a41a 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/terms/TermsTest.java @@ -4,6 +4,7 @@ import java.util.List; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; @@ -30,4 +31,15 @@ public void stringsAsTermList() { assertEquals("\"blubb\"", terms.get(1).toString()); } + /** + * Reproduction test for an error observed while testing evolog actions. + */ + @Test + public void functionTermVsActionSuccessTermHash() { + FunctionTerm funcTerm = Terms.newFunctionTerm("success", Terms.newFunctionTerm("stream", Terms.newConstant("outputStream_2"))); + FunctionTerm actionSuccessTerm = Terms.actionSuccess(Terms.newFunctionTerm("stream", Terms.newConstant("outputStream_2"))); + assertEquals(funcTerm, actionSuccessTerm); + assertEquals(funcTerm.hashCode(), actionSuccessTerm.hashCode()); + } + } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java index 2be5302a5..2fe7b710a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/grounder/IndexedInstanceStorage.java @@ -112,7 +112,8 @@ public void removeIndexPosition(int position) { * @return true if the instance is already contained in the storage. */ public boolean containsInstance(Instance instance) { - return instances.contains(instance); + boolean contains = instances.contains(instance); + return contains; // TODO remove extra variable, debugging only } public void addInstance(Instance instance) { From 8d864458343f10771ccc6b2610446f9c0e86f221 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 9 Jan 2024 21:14:51 +0100 Subject: [PATCH 90/96] Fix ActionsTest: check answer set content for answer set of write file program. --- .../tuwien/kr/alpha/commons/AnswerSets.java | 4 ++ .../core/actions/OutputStreamHandle.java | 2 + .../MockActionImplementationProvider.java | 4 +- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 64 +++++++++++++++++-- 4 files changed, 67 insertions(+), 7 deletions(-) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSets.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSets.java index 0587e51d8..6b22bbaaf 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSets.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/AnswerSets.java @@ -19,4 +19,8 @@ public static AnswerSet newAnswerSet(SortedSet predicates, Map or some such public class OutputStreamHandle implements Comparable { private final int id; diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java index d830b6831..affe5f555 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/MockActionImplementationProvider.java @@ -61,7 +61,7 @@ protected InputStream getStdinStream() { } @Override - protected OutputStream getFileOutputStream(String path) throws IOException { + public OutputStream getFileOutputStream(String path) throws IOException { if (mockedFileOutputs.containsKey(path)) { return mockedFileOutputs.get(path); } @@ -69,7 +69,7 @@ protected OutputStream getFileOutputStream(String path) throws IOException { } @Override - protected InputStream getInputStream(String path) throws IOException { + public InputStream getInputStream(String path) throws IOException { if (mockedFileInputs.containsKey(path)) { return mockedFileInputs.get(path); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 37c49a1ba..85cad097d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -2,14 +2,35 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.ByteArrayOutputStream; import java.io.OutputStream; +import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.api.AnswerSetQuery; +import at.ac.tuwien.kr.alpha.api.programs.Predicate; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.commons.AnswerSets; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.AnswerSetQueryImpl; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; +import at.ac.tuwien.kr.alpha.core.actions.OutputStreamHandle; +import at.ac.tuwien.kr.alpha.test.AlphaAssertions; +import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; +import com.ibm.icu.impl.Assert; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.slf4j.Logger; @@ -48,21 +69,54 @@ public void helloWorld() { } @Test - @Disabled + //@Disabled + @SuppressWarnings("unchecked") public void writeToFile() { Map mockedFileOutputs = new HashMap<>(); ByteArrayOutputStream dummyFileContent = new ByteArrayOutputStream(); mockedFileOutputs.put("dummy.file", dummyFileContent); MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); alphaFactory.getActionImplementationMock().setMockedFileOutputs(mockedFileOutputs); + ActionImplementationProvider actionProvider = alphaFactory.getActionImplementationMock(); Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); InputProgram program = alpha.readProgramString(WRITE_TO_FILE); Set answerSets = alpha.solve(program).collect(Collectors.toSet()); LOGGER.debug("Got answer sets: {}", answerSets); - assertAnswerSetsEqual( - "outfile(\"dummy.file\"), outfile_open_result(\"dummy.file\", success(stream(outputStream_2)))," - + " outfile_write_result(\"dummy.file\", success(ok)), outfile_close_result(\"dummy.file\", success(ok))", - answerSets); + assertEquals(1, answerSets.size()); + AnswerSet answerSet = answerSets.stream().findFirst().get(); + /* + * Note: We have to check answer set content here because we have no way of constructing an equal instance for + * the outputStreamHandle that is constructed when execution the "fileOutputStream" action. * + */ + assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_open_result", 2)) + .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) + .withFunctionTerm(1, "success", 1) + .withFilter(1, (term) -> { + FunctionTerm funcTerm = (FunctionTerm) term; + assertEquals(1, funcTerm.getTerms().size()); + assertTrue(funcTerm.getTerms().get(0) instanceof FunctionTerm && ((FunctionTerm) funcTerm.getTerms().get(0)).getSymbol().equals("stream")); + ConstantTerm streamTerm = (ConstantTerm) ((FunctionTerm) funcTerm.getTerms().get(0)).getTerms().get(0); + return streamTerm.getObject() instanceof OutputStreamHandle; + }) + ).size()); + assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_write_result", 2)) + .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) + .withFunctionTerm(1, "success", 1) + .withFilter(1, (term) -> { + FunctionTerm funcTerm = (FunctionTerm) term; + assertEquals(1, funcTerm.getTerms().size()); + return funcTerm.getTerms().get(0) instanceof ConstantTerm && ((ConstantTerm) funcTerm.getTerms().get(0)).getObject().equals("ok"); + }) + ).size()); + assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_close_result", 2)) + .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) + .withFunctionTerm(1, "success", 1) + .withFilter(1, (term) -> { + FunctionTerm funcTerm = (FunctionTerm) term; + assertEquals(1, funcTerm.getTerms().size()); + return funcTerm.getTerms().get(0) instanceof ConstantTerm && ((ConstantTerm) funcTerm.getTerms().get(0)).getObject().equals("ok"); + }) + ).size()); assertEquals("Foo bar!", dummyFileContent.toString()); } From 0bb76b19067bf97f21a28f665817514249c8c6bd Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 9 Jan 2024 21:21:48 +0100 Subject: [PATCH 91/96] Fix checkstyle violations --- .../java/at/ac/tuwien/kr/alpha/ActionsTest.java | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 85cad097d..1ddfaa7cc 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,37 +1,21 @@ package at.ac.tuwien.kr.alpha; import static org.junit.jupiter.api.Assertions.assertEquals; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.ByteArrayOutputStream; import java.io.OutputStream; -import java.util.ArrayList; -import java.util.Collections; import java.util.HashMap; -import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; -import at.ac.tuwien.kr.alpha.api.AnswerSetQuery; -import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.AnswerSetQueryImpl; import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.actions.OutputStreamHandle; -import at.ac.tuwien.kr.alpha.test.AlphaAssertions; -import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; -import com.ibm.icu.impl.Assert; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; From 01c70382d75197166dabb651faf5bf742219ab47 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Thu, 11 Jan 2024 21:39:58 +0100 Subject: [PATCH 92/96] add simple evolog examples --- examples/greet-me.evl | 7 +++++++ examples/write_something.evl | 9 +++++++++ 2 files changed, 16 insertions(+) create mode 100644 examples/greet-me.evl create mode 100644 examples/write_something.evl diff --git a/examples/greet-me.evl b/examples/greet-me.evl new file mode 100644 index 000000000..8bf5bdcda --- /dev/null +++ b/examples/greet-me.evl @@ -0,0 +1,7 @@ +prompt_text("Hello user, what's your name? "). +write_prompt_res(R) : @streamWrite[STDOUT, PROMPT] = R :- prompt_text(PROMPT), &stdout(STDOUT). +usr_input_res(INP) : @streamReadLine[STDIN] = INP :- write_prompt_res(success(_)), &stdin(STDIN). +write_greeting_res(R) : @streamWrite[STDOUT, GREETING] = R :- + usr_input_res(success(line(NAME))), + &stdlib_string_concat["Hello, it is the utmost pleasure to finally greet you from an Evolog program, ", NAME](GREETING), + &stdout(STDOUT). diff --git a/examples/write_something.evl b/examples/write_something.evl new file mode 100644 index 000000000..cb113762b --- /dev/null +++ b/examples/write_something.evl @@ -0,0 +1,9 @@ +outfile("/home/michael/asp_snippets/evolog-actions/hello.out"). + +open_result(PATH, RES) : @fileOutputStream[PATH] = RES :- outfile(PATH). + +write_result(PATH, RES) : @streamWrite[STREAM, "HelloEvologWorld!"] = RES :- open_result(PATH, success(stream(STREAM))), outfile(PATH). + +can_close(PATH, FD) :- write_result(PATH, success(ok)), open_result(PATH, success(stream(FD))), outfile(PATH). + +close_result(PATH, RES) : @outputStreamClose[STREAM] = RES :- write_result(PATH, success(ok)), open_result(PATH, success(stream(STREAM))), outfile(PATH). From 8191e8979a37e1ce5bffa3598420dcd6917ac6a8 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 26 May 2024 17:25:31 +0200 Subject: [PATCH 93/96] WIP: merge action implementation back into state from master --- .../java/at/ac/tuwien/kr/alpha/api/Alpha.java | 26 ++--- .../at/ac/tuwien/kr/alpha/api/AnswerSet.java | 2 +- .../alpha/api/programs/ASPCore2Program.java | 21 ---- .../kr/alpha/api/programs/InputProgram.java | 13 ++- .../api/programs/rules/RuleInstantiator.java | 11 ++ .../api/programs/rules/heads/ActionHead.java | 16 +++ .../rules/heads/InstantiableHead.java | 11 ++ .../api/programs/terms/ActionResultTerm.java | 30 +++++ .../alpha/api/programs/tests/Assertion.java | 4 +- .../commons/programs/ASPCore2ProgramImpl.java | 5 +- .../kr/alpha/commons/programs/Programs.java | 22 ++-- .../alpha/commons/programs/rules/Rules.java | 11 +- .../programs/rules/heads/ActionHeadImpl.java | 63 +++++++++++ .../commons/programs/rules/heads/Heads.java | 6 + .../programs/rules/heads/NormalHeadImpl.java | 7 ++ .../terms/AbstractActionResultTerm.java | 26 +++++ .../programs/terms/ActionErrorTerm.java | 24 ++++ .../programs/terms/ActionSuccessTerm.java | 25 +++++ .../alpha/commons/programs/terms/Terms.java | 17 +-- .../ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 | 4 +- ...gramParser.java => ProgramParserImpl.java} | 20 ++-- .../core/programs/rules/InternalRule.java | 106 +++--------------- ...mer.java => ArithmeticTermsRewriting.java} | 20 ++-- ...ormalizer.java => ChoiceHeadToNormal.java} | 5 +- 24 files changed, 320 insertions(+), 175 deletions(-) delete mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java create mode 100644 alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java create mode 100644 alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{AbstractProgramParser.java => ProgramParserImpl.java} (84%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ArithmeticTermTransformer.java => ArithmeticTermsRewriting.java} (89%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ChoiceHeadNormalizer.java => ChoiceHeadToNormal.java} (96%) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java index 2cc01b42a..74ef89dac 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java @@ -28,18 +28,18 @@ public interface Alpha { * * @param cfg and {@link InputConfig} specifying program sources (strings, files) as well as config metadata (e.g. literate program, * external atoms, etc) - * @return an {@link ASPCore2Program} representing the parsed ASP code from all sources referenced in the given {@link InputConfig} + * @return an {@link InputProgram} representing the parsed ASP code from all sources referenced in the given {@link InputConfig} * @throws IOException in case one or more program sources (e.g. files) cannot be read, or parsing fails */ InputProgram readProgram(InputConfig cfg) throws IOException; /** - * Reads and parses an {@link ASPCore2Program} from a list of {@link String}s representing paths. + * Reads and parses an {@link InputProgram} from a list of {@link String}s representing paths. * * @param literate flag indicating whether ASP code should be treated as "literate". * @param externals Custom {@link PredicateInterpretation}s for user-defined external atoms * @param paths a list of {@link String}s representing paths containing all sources from which ASP code should be read - * @return an {@link ASPCore2Program} representing the parsed ASP code from all given path strings + * @return an {@link InputProgram} representing the parsed ASP code from all given path strings * @throws IOException in case one or more program sources cannot be read, or parsing fails */ InputProgram readProgramFiles(boolean literate, Map externals, List paths) throws IOException; @@ -50,12 +50,12 @@ public interface Alpha { InputProgram readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException; /** - * Parses a given String into an {@link ASPCore2Program}, using a map of custom {@link PredicateInterpretation}s to resolve external atoms + * Parses a given String into an {@link InputProgram}, using a map of custom {@link PredicateInterpretation}s to resolve external atoms * in ASP code. * * @param aspString a string representing a valid ASP-Core2 program * @param externals a map of custom {@link PredicateInterpretation}s against which external atoms in the given code are resolved - * @return an {@link ASPCore2Program} representing the parsed ASP code + * @return an {@link InputProgram} representing the parsed ASP code */ InputProgram readProgramString(String aspString, Map externals); @@ -75,7 +75,7 @@ public interface Alpha { InputProgram readProgramStream(InputStream is, Map externals) throws IOException; /** - * Prepares a {@link DebugSolvingContext} for the given {@link ASPCore2Program} to debug program preprocessing. + * Prepares a {@link DebugSolvingContext} for the given {@link InputProgram} to debug program preprocessing. * * @return a {@link DebugSolvingContext} holding debug information for the given program */ @@ -89,7 +89,7 @@ public interface Alpha { DebugSolvingContext prepareDebugSolve(final NormalProgram program); /** - * Prepares a {@link DebugSolvingContext} for the given {@link ASPCore2Program} to debug program preprocessing. + * Prepares a {@link DebugSolvingContext} for the given {@link InputProgram} to debug program preprocessing. * * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link DebugSolvingContext} holding debug information for the given program @@ -105,7 +105,7 @@ public interface Alpha { DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.util.function.Predicate filter); /** - * Solves the given {@link ASPCore2Program}. + * Solves the given {@link InputProgram}. * * @param program an input program * @return a {@link Stream} of {@link AnswerSet}s of the given program @@ -113,7 +113,7 @@ public interface Alpha { Stream solve(InputProgram program); /** - * Solves the given {@link ASPCore2Program}. + * Solves the given {@link InputProgram}. * * @param program an input program * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. @@ -143,13 +143,13 @@ public interface Alpha { * code. * See {@link NormalProgram}, * - * @param program An {@link ASPCore2Program} to normalize + * @param program An {@link InputProgram} to normalize * @return a {@link NormalProgram} that is a semantic equivalent to the given input program */ NormalProgram normalizeProgram(InputProgram program); /** - * Constructs a @{link Solver} pre-loaded with the given {@link ASPCore2Program} from which {@link AnswerSet}s can be obtained via + * Constructs a @{link Solver} pre-loaded with the given {@link InputProgram} from which {@link AnswerSet}s can be obtained via * {@link Solver#stream()}. * * @param program the program to solve @@ -174,11 +174,11 @@ public interface Alpha { * @param program an ASP program to reify * @return a set of {@link BasicAtom}s encoding the given program */ - Set reify(ASPCore2Program program); + Set reify(InputProgram program); /** * Runs all test cases of the given program. */ - TestResult test(ASPCore2Program program); + TestResult test(InputProgram program); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java index 1015fb833..8b80fc9ef 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java @@ -32,7 +32,7 @@ public interface AnswerSet extends Comparable { boolean isEmpty(); /** - * List {@link Atom}s in this answer set satisfying the given {@link AnswerSetQuery}. + * List {@link Atom}s in this answer set satisfying the given {@link AtomQuery}. */ List query(AtomQuery query); diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java deleted file mode 100644 index fa444b184..000000000 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java +++ /dev/null @@ -1,21 +0,0 @@ -package at.ac.tuwien.kr.alpha.api.programs; - -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; - -import java.util.List; - -/** - * A {@link Program} that conforms to Alphas implementation of the ASP-Core2-Standard. - * - * Copyright (c) 2021, the Alpha Team. - */ -public interface ASPCore2Program extends Program> { - - /** - * The test cases associated with this program. - */ - List getTestCases(); - -} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java index c7be5bd2f..f9fe5122f 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java @@ -1,9 +1,16 @@ package at.ac.tuwien.kr.alpha.api.programs; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; + +import java.util.List; -// TODO javadoc public interface InputProgram extends Program> { + /** + * The test cases associated with this program. + */ + List getTestCases(); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java new file mode 100644 index 000000000..74646f00d --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.InstantiableHead; + +public interface RuleInstantiator { + + BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java new file mode 100644 index 000000000..744531317 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java @@ -0,0 +1,16 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; + +import java.util.List; + +public interface ActionHead extends NormalHead { + + String getActionName(); + + List getActionInputTerms(); + + VariableTerm getActionOutputTerm(); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java new file mode 100644 index 000000000..82aa89343 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; + +public interface InstantiableHead extends Head { + + BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java new file mode 100644 index 000000000..28fc53769 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java @@ -0,0 +1,30 @@ +package at.ac.tuwien.kr.alpha.api.programs.terms; + + /** + * A term representing the result of an evolog action (i.e. result of action function application). + * Action result terms are function terms with symbol "success" or "error" depending on whether the corresponding action was sucessful. + * There is always one argument which is either some term representing the actual function result or an error message, respectively. + */ +public interface ActionResultTerm extends FunctionTerm { + + public static final String SUCCESS_SYMBOL = "success"; + public static final String ERROR_SYMBOL = "error"; + + /** + * True if the action that generated this result was successful (i.e. executed normally). + */ + boolean isSuccess(); + + /** + * True if the action that generated this result failed (i.e. threw an error in execution). + */ + boolean isError(); + + /** + * Gets the actual value wrapped in this result. + * Either a term representing the action return value or a string term representing an error + * message.s + */ + T getValue(); + +} \ No newline at end of file diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java index 70da34ddc..4acf1e5f8 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs.tests; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; public interface Assertion { @@ -23,7 +23,7 @@ public String toString() { Mode getMode(); - ASPCore2Program getVerifier(); + InputProgram getVerifier(); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java index 32c5ccacf..c67097ed3 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.commons.programs; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -43,7 +43,8 @@ *

* Copyright (c) 2017-2019, the Alpha Team. */ -class ASPCore2ProgramImpl extends AbstractProgram> implements ASPCore2Program{ +// TODO rename this to InputProgramImpl or some such +class ASPCore2ProgramImpl extends AbstractProgram> implements InputProgram { static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl(), Collections.emptyList()); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java index e42a486fe..460231815 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -6,6 +6,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; @@ -20,15 +21,17 @@ private Programs() { throw new AssertionError("Cannot instantiate utility class!"); } - public static ASPCore2Program emptyProgram() { + public static InputProgram emptyProgram() { return ASPCore2ProgramImpl.EMPTY; } - public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { + // TODO rename method + public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, testCases); } - public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { + // TODO rename method + public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, Collections.emptyList()); } @@ -36,7 +39,7 @@ public static ASPCore2ProgramBuilder builder() { return new ASPCore2ProgramBuilder(); } - public static ASPCore2ProgramBuilder builder(ASPCore2Program program) { + public static ASPCore2ProgramBuilder builder(InputProgram program) { return new ASPCore2ProgramBuilder(program); } @@ -44,7 +47,7 @@ public static NormalProgram newNormalProgram(List rules, List return new NormalProgramImpl(rules, facts, inlineDirectives); } - public static NormalProgram toNormalProgram(ASPCore2Program inputProgram) { + public static NormalProgram toNormalProgram(InputProgram inputProgram) { List normalRules = new ArrayList<>(); for (Rule r : inputProgram.getRules()) { normalRules.add(Rules.toNormalRule(r)); @@ -57,8 +60,9 @@ public static InlineDirectives newInlineDirectives() { } /** - * Builder for more complex program construction scenarios, ensuring that an {@link AspCore2ProgramImpl} is immutable + * Builder for more complex program construction scenarios, ensuring that an {@link ASPCore2ProgramImpl} is immutable */ + // TODO maybe rename public static class ASPCore2ProgramBuilder { private List> rules = new ArrayList<>(); @@ -67,7 +71,7 @@ public static class ASPCore2ProgramBuilder { private List testCases = new ArrayList<>(); - public ASPCore2ProgramBuilder(ASPCore2Program prog) { + public ASPCore2ProgramBuilder(InputProgram prog) { this.addRules(prog.getRules()); this.addFacts(prog.getFacts()); this.addInlineDirectives(prog.getInlineDirectives()); @@ -113,11 +117,11 @@ public ASPCore2ProgramBuilder addTestCases(List testCases) { return this; } - public ASPCore2ProgramBuilder accumulate(ASPCore2Program prog) { + public ASPCore2ProgramBuilder accumulate(InputProgram prog) { return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()).addTestCases(prog.getTestCases()); } - public ASPCore2Program build() { + public InputProgram build() { return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives, this.testCases); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index dc0396863..3d04c53f9 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -23,10 +24,7 @@ public static Rule newRule(Head head, List body) { } public static Rule newRule(Head head, Literal... body) { - List bodyLst = new ArrayList<>(); - for (Literal lit : body) { - bodyLst.add(lit); - } + List bodyLst = new ArrayList<>(Arrays.asList(body)); return new BasicRule(head, bodyLst); } @@ -35,10 +33,7 @@ public static NormalRule newNormalRule(NormalHead head, List body) { } public static NormalRule newNormalRule(NormalHead head, Literal... body) { - List bodyLst = new ArrayList<>(); - for (Literal lit : body) { - bodyLst.add(lit); - } + List bodyLst = new ArrayList<>(Arrays.asList(body)); return new NormalRuleImpl(head, bodyLst); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java new file mode 100644 index 000000000..46a598442 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java @@ -0,0 +1,63 @@ +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import org.apache.commons.lang3.StringUtils; + +import java.util.Collections; +import java.util.List; + +class ActionHeadImpl implements ActionHead { + + private final BasicAtom atom; + private final String actionName; + private final List actionInputTerms; + private final VariableTerm actionOutputTerm; + + ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { + this.atom = atom; + this.actionName = actionName; + this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); + this.actionOutputTerm = actionOutputTerm; + } + + @Override + public BasicAtom getAtom() { + return atom; + } + + @Override + public boolean isGround() { + // TODO: an action head is conceptually a basic one with an (interpreted) function term + return false; + } + + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + + @Override + public String getActionName() { + return actionName; + } + + @Override + public List getActionInputTerms() { + return actionInputTerms; + } + + @Override + public VariableTerm getActionOutputTerm() { + return actionOutputTerm; + } + + public String toString() { + return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java index 6e7aeebf1..3ebf81b63 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java @@ -5,10 +5,12 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; public final class Heads { @@ -29,5 +31,9 @@ public static ChoiceHead newChoiceHead(List choiceElements, Term public static ChoiceElement newChoiceElement(BasicAtom choiceAtom, List conditionLiterals) { return new ChoiceElementImpl(choiceAtom, conditionLiterals); } + + public static ActionHead newActionHead(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionResult) { + return new ActionHeadImpl(atom, actionName, actionInputTerms, actionResult); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java index 7bae74aba..1422d8e75 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java @@ -1,6 +1,8 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; /** @@ -26,6 +28,11 @@ public BasicAtom getAtom() { return atom; } + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + @Override public String toString() { return atom.toString(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java new file mode 100644 index 000000000..9a94e942d --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java @@ -0,0 +1,26 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; + +import java.util.Collections; + +abstract class AbstractActionResultTerm extends FunctionTermImpl implements ActionResultTerm { + + AbstractActionResultTerm(String symbol, T value) { + super(symbol, Collections.singletonList(value)); + } + + public abstract boolean isSuccess(); + + public boolean isError() { + return !isSuccess(); + } + + // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. + @SuppressWarnings("unchecked") + public T getValue() { + return (T) getTerms().get(0); + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java new file mode 100644 index 000000000..683b640c1 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java @@ -0,0 +1,24 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionErrorTerm extends AbstractActionResultTerm> { + + private static final Interner INTERNER = new Interner<>(); + + ActionErrorTerm(ConstantTerm value) { + super(ActionResultTerm.ERROR_SYMBOL, value); + } + + public static ActionErrorTerm getInstance(ConstantTerm term) { + return INTERNER.intern(new ActionErrorTerm(term)); + } + + @Override + public boolean isSuccess() { + return false; + } + +} \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java new file mode 100644 index 000000000..2c4d7ddfd --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java @@ -0,0 +1,25 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionSuccessTerm extends AbstractActionResultTerm { + + private static final Interner> INTERNER = new Interner<>(); + + ActionSuccessTerm(T value) { + super(ActionResultTerm.SUCCESS_SYMBOL, value); + } + + @SuppressWarnings("unchecked") + public static ActionSuccessTerm getInstance(T term) { + return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); + } + + @Override + public boolean isSuccess() { + return true; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java index d38088b6b..7d0ac9971 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java @@ -5,13 +5,7 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.*; import at.ac.tuwien.kr.alpha.commons.programs.terms.ArithmeticTermImpl.MinusTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; @@ -70,6 +64,15 @@ public static IntervalTerm newIntervalTerm(Term lowerBound, Term upperBound) { return IntervalTermImpl.getInstance(lowerBound, upperBound); } + public static ActionResultTerm actionSuccess(T value) { + return ActionSuccessTerm.getInstance(value); + } + + public static ActionResultTerm> actionError(String errMsg) { + return ActionErrorTerm.getInstance(Terms.newConstant(errMsg)); + } + + @SafeVarargs public static > List> asTermList(T... values) { List> retVal = new ArrayList<>(); diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index 44039084e..bbd952cad 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -20,7 +20,9 @@ statement : head DOT # statement_fact | WCONS body? DOT SQUARE_OPEN weight_at_level SQUARE_CLOSE # statement_weightConstraint | directive # statement_directive; // NOT Core2 syntax. -head : disjunction | choice; +head : disjunction | choice | action; + +action: classical_literal COLON AT ID SQUARE_OPEN terms SQUARE_CLOSE EQUAL variable_term; // NOT Core2 syntax body : ( naf_literal | aggregate ) (COMMA body)?; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java similarity index 84% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java index cc63f903d..64e36c247 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java @@ -7,6 +7,7 @@ import java.util.HashMap; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import org.antlr.v4.runtime.BailErrorStrategy; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; @@ -17,12 +18,9 @@ import org.antlr.v4.runtime.misc.ParseCancellationException; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.externals.Externals; public class ProgramParserImpl implements ProgramParser { @@ -39,12 +37,12 @@ public ProgramParserImpl(Map externals) { } @Override - public ASPCore2Program parse(String s) { + public InputProgram parse(String s) { return parse(s, Collections.emptyMap()); } @Override - public ASPCore2Program parse(String s, Map externals) { + public InputProgram parse(String s, Map externals) { try { return parse(CharStreams.fromString(s), externals); } catch (RecognitionException | ParseCancellationException e) { @@ -55,11 +53,11 @@ public ASPCore2Program parse(String s, Map exte } } - public ASPCore2Program parse(CharStream stream) { + public InputProgram parse(CharStream stream) { return parse(stream, Collections.emptyMap()); } - public ASPCore2Program parse(CharStream stream, Map externals) { + public InputProgram parse(CharStream stream, Map externals) { //@formatter:off /* * // In order to require less memory: use unbuffered streams and avoid constructing a full parse tree. @@ -132,17 +130,17 @@ public ASPCore2Program parse(CharStream stream, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(InputStream programSource, Map externalPredicateDefinitions) throws IOException { return parse(CharStreams.fromStream(programSource), externalPredicateDefinitions); } @Override - public ASPCore2Program parse(Path programPath, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(Path programPath, Map externalPredicateDefinitions) throws IOException { return parse(CharStreams.fromPath(programPath), externalPredicateDefinitions); } @Override - public ASPCore2Program parse(Map externalPredicateDefinitions, Path... programSources) throws IOException { + public InputProgram parse(Map externalPredicateDefinitions, Path... programSources) throws IOException { ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); @@ -151,7 +149,7 @@ public ASPCore2Program parse(Map externalPredic } @Override - public ASPCore2Program parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index fb998a297..8b57907f2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -25,37 +25,18 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -package at.ac.tuwien.kr.alpha.core.rules; - -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -import com.google.common.annotations.VisibleForTesting; -======== package at.ac.tuwien.kr.alpha.core.programs.rules; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -======== import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.AbstractRule; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; @@ -70,23 +51,15 @@ * * {@link InternalRule}s are assumed to be uniquely identified by an ID. */ -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -public class CompiledRuleImpl implements CompiledRule { -======== public class InternalRule extends AbstractRule implements CompiledRule { ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java private static final IntIdGenerator ID_GENERATOR = new IntIdGenerator(); - private final NormalRule wrappedRule; - private final int ruleId; + private final List occurringPredicates; + private final RuleGroundingInfoImpl groundingOrders; -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - - CompiledRuleImpl(NormalHead head, Set body) { -======== /** * Creates a new {@link InternalRule} with the given head plus body and a fresh identifier. @@ -96,13 +69,11 @@ public class InternalRule extends AbstractRule implements CompiledRu */ public InternalRule(NormalHead head, List body) { super(head, body); ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java if (body.isEmpty()) { throw new IllegalArgumentException( "Empty bodies are not supported for InternalRule! (Head = " + (head == null ? "NULL" : head.getAtom().toString()) + ")"); } - this.ruleId = CompiledRuleImpl.ID_GENERATOR.getNextId(); - this.wrappedRule = Rules.newNormalRule(head, body); + this.ruleId = InternalRule.ID_GENERATOR.getNextId(); this.occurringPredicates = new ArrayList<>(); if (!isConstraint()) { @@ -116,24 +87,32 @@ public InternalRule(NormalHead head, List body) { this.occurringPredicates.add(literal.getPredicate()); } + // not needed, done in AbstractRule! Leaving it commented out for future reference since this might actually be the + // proper place to put it + // this.checkSafety(); + this.groundingOrders = new RuleGroundingInfoImpl(this); this.groundingOrders.computeGroundingOrders(); } @VisibleForTesting public static void resetIdGenerator() { - CompiledRuleImpl.ID_GENERATOR.resetGenerator(); + InternalRule.ID_GENERATOR.resetGenerator(); + } + + public static CompiledRule fromNormalRule(Rule rule) { + return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new ArrayList<>(rule.getBody())); } /** * Returns a new Rule that is equal to this one except that all variables are renamed to have the newVariablePostfix * appended. - * + * * @param newVariablePostfix * @return */ @Override - public CompiledRuleImpl renameVariables(String newVariablePostfix) { + public InternalRule renameVariables(String newVariablePostfix) { // TODO handle action heads! List occurringVariables = new ArrayList<>(); BasicAtom headAtom = this.getHeadAtom(); @@ -147,13 +126,13 @@ public CompiledRuleImpl renameVariables(String newVariablePostfix) { variableReplacement.put(occurringVariable, Terms.newVariable(newVariableName)); } BasicAtom renamedHeadAtom = headAtom.substitute(variableReplacement); - Set renamedBody = new LinkedHashSet<>(this.getBody().size()); + ArrayList renamedBody = new ArrayList<>(this.getBody().size()); for (Literal literal : this.getBody()) { renamedBody.add(literal.substitute(variableReplacement)); } // TODO action heads! // TODO we want to pull renameVariables down to atom, term, etc level - return new CompiledRuleImpl(Heads.newNormalHead(renamedHeadAtom), renamedBody); + return new InternalRule(Heads.newNormalHead(renamedHeadAtom), renamedBody); } /** @@ -175,46 +154,6 @@ public int getRuleId() { return this.ruleId; } - @Override -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - public BasicAtom getHeadAtom() { - return wrappedRule.getHeadAtom(); - } - - @Override - public NormalHead getHead() { - return wrappedRule.getHead(); - } - - @Override - public Set getBody() { - return wrappedRule.getBody(); - } - - @Override - public boolean isConstraint() { - return wrappedRule.isConstraint(); - } - - @Override - public Set getPositiveBody() { - return wrappedRule.getPositiveBody(); - } - - @Override - public Set getNegativeBody() { - return wrappedRule.getNegativeBody(); - } - - @Override - public boolean isGround() { - return wrappedRule.isGround(); - } - - @Override - public String toString() { - return wrappedRule.toString(); -======== public boolean isGround() { if (!isConstraint() && !getHead().isGround()) { return false; @@ -225,14 +164,10 @@ public boolean isGround() { } } return true; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java } @Override public boolean equals(Object o) { -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - return wrappedRule.equals(o); -======== if (this == o) { return true; } @@ -241,17 +176,12 @@ public boolean equals(Object o) { } InternalRule that = (InternalRule) o; return getRuleId() == that.getRuleId(); ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java } @Override public int hashCode() { -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - return wrappedRule.hashCode(); - } - -======== return Integer.hashCode(getRuleId()); } ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java + } + diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java similarity index 89% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index b556c642a..029123628 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -22,6 +22,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; /** @@ -32,8 +33,12 @@ * Copyright (c) 2020-2021, the Alpha Team. */ public class ArithmeticTermsRewriting extends ProgramTransformation { - private static final String ARITHMETIC_VARIABLES_PREFIX = "_A"; - private int numArithmeticVariables; + /** + private int numArithmeticVariables; + * The prefix with which to begin names of internal variables created by this transformation. + */ + private final String generatedVariablesPrefix = "_A"; + private final IntIdGenerator variableNumberGenerator = new IntIdGenerator(); @Override public NormalProgram apply(NormalProgram inputProgram) { @@ -57,19 +62,20 @@ public NormalProgram apply(NormalProgram inputProgram) { /** * Takes a normal rule and rewrites it such that {@link ArithmeticTerm}s only appear inside - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}s. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}s. * * @param inputProgramRule the rule to rewrite. * @return the rewritten rule. Note that a new {@link NormalRule} is returned for every call of this method. */ private NormalRule rewriteRule(NormalRule inputProgramRule) { - numArithmeticVariables = 0; // Reset number of introduced variables for each rule. + variableNumberGenerator.resetGenerator(); // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; List rewrittenBodyLiterals = new ArrayList<>(); // Rewrite head. if (!inputProgramRule.isConstraint()) { BasicAtom headAtom = inputProgramRule.getHeadAtom(); if (containsArithmeticTermsToRewrite(headAtom)) { + // TODO handle action heads rewrittenHead = Heads.newNormalHead((BasicAtom) rewriteAtom(headAtom, rewrittenBodyLiterals)); } else { rewrittenHead = inputProgramRule.getHead(); @@ -89,11 +95,11 @@ private NormalRule rewriteRule(NormalRule inputProgramRule) { /** * Checks whether a normal rule contains an {@link ArithmeticTerm} outside of a - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}. * * @param inputProgramRule the rule to check for presence of arithmetic terms outside comparison literals. * @return true if the inputProgramRule contains an {@link ArithmeticTerm} outside of a - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}. */ private boolean containsArithmeticTermsToRewrite(NormalRule inputProgramRule) { if (!inputProgramRule.isConstraint()) { @@ -118,7 +124,7 @@ private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { } // Switch on term type. if (term instanceof ArithmeticTerm) { - VariableTerm replacementVariable = Terms.newVariable(ARITHMETIC_VARIABLES_PREFIX + numArithmeticVariables++); + VariableTerm replacementVariable = Terms.newVariable(generatedVariablesPrefix + variableNumberGenerator.getNextId()); bodyLiterals.add(Atoms.newComparisonAtom(replacementVariable, term, ComparisonOperators.EQ).toLiteral()); return replacementVariable; } else if (term instanceof VariableTerm || term instanceof ConstantTerm) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java similarity index 96% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 5783dd2d9..486c57e12 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -32,6 +32,7 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -53,11 +54,11 @@ * Copyright (c) 2017-2021, the Alpha Team. */ // TODO this could already give NormalProgram as result type -public class ChoiceHeadToNormal extends ProgramTransformation { +public class ChoiceHeadToNormal extends ProgramTransformation { private final static String PREDICATE_NEGATION_PREFIX = "_n"; @Override - public ASPCore2Program apply(ASPCore2Program inputProgram) { + public InputProgram apply(InputProgram inputProgram) { ASPCore2ProgramBuilder programBuilder = Programs.builder(); List> additionalRules = new ArrayList<>(); From 133553ff1d160b9fa5ffd12557cc33f355d25368 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Sun, 7 Jul 2024 18:20:24 +0200 Subject: [PATCH 94/96] WIP: fix tests after merging action implementation into latest master state --- .../api/config/AggregateRewritingConfig.java | 2 +- .../kr/alpha/api/programs/InputProgram.java | 8 +- .../kr/alpha/api/programs/actions/Action.java | 6 +- .../alpha/api/programs/rules/NormalRule.java | 2 + .../api/programs/rules/RuleInstantiator.java | 2 +- .../api/programs/rules/heads/ActionHead.java | 6 +- .../rules/heads/InstantiableHead.java | 2 +- .../api/programs/terms/ActionResultTerm.java | 42 +++--- .../kr/alpha/commons/externals/Externals.java | 26 +--- .../PredicateInterpretationImpl.java | 7 +- ...ProgramImpl.java => InputProgramImpl.java} | 6 +- .../kr/alpha/commons/programs/Programs.java | 47 ++++--- .../commons/programs/reification/Reifier.java | 5 +- .../commons/programs/rules/AbstractRule.java | 2 +- .../commons/programs/rules/BasicRule.java | 3 +- .../programs/rules/NormalRuleImpl.java | 16 ++- .../alpha/commons/programs/rules/Rules.java | 14 +- .../commons/programs/tests/AssertionImpl.java | 8 +- .../alpha/commons/programs/tests/Tests.java | 4 +- .../AbstractActionImplementationProvider.java | 22 ++-- .../core/actions/ActionExecutionService.java | 6 +- .../actions/ActionExecutionServiceImpl.java | 4 +- .../kr/alpha/core/actions/ActionWitness.java | 6 +- ...TreeVisitor.java => ParseTreeVisitor.java} | 35 +++-- .../alpha/core/parser/ProgramParserImpl.java | 17 ++- ...PartParser.java => ProgramPartParser.java} | 9 +- .../aspcore2/ASPCore2ProgramParser.java | 23 ---- .../parser/evolog/EvologParseTreeVisitor.java | 34 ----- .../parser/evolog/EvologProgramParser.java | 27 ---- .../alpha/core/programs/InternalProgram.java | 2 +- .../core/programs/rules/InternalRule.java | 8 +- .../ArithmeticTermsRewriting.java | 8 +- .../transformation/ChoiceHeadToNormal.java | 13 +- ...sformer.java => EnumerationRewriting.java} | 17 +-- ...r.java => IntervalTermToIntervalAtom.java} | 7 +- .../NormalizeProgramTransformation.java | 8 +- .../transformation/PredicateInternalizer.java | 18 +-- .../transformation/ProgramNormalizer.java | 54 -------- ...former.java => ProgramTransformation.java} | 4 +- .../transformation/StratifiedEvaluation.java | 122 ++++++++++++++--- ...rmer.java => VariableEqualityRemoval.java} | 20 +-- .../aggregates/AggregateLiteralSplitting.java | 14 +- .../AggregateOperatorNormalization.java | 10 +- ...ansformer.java => AggregateRewriting.java} | 38 +++--- .../aggregates/AggregateRewritingContext.java | 20 +-- .../AggregateRewritingRuleAnalysis.java | 13 +- .../encoders/AbstractAggregateEncoder.java | 33 ++--- .../encoders/AggregateEncoders.java | 24 ++-- .../aggregates/encoders/CountEncoder.java | 12 +- .../aggregates/encoders/MinMaxEncoder.java | 12 +- .../StringtemplateBasedAggregateEncoder.java | 24 ++-- .../aggregates/encoders/SumEncoder.java | 12 +- .../kr/alpha/core/rules/CompiledRules.java | 6 +- .../kr/alpha/core/solver/TrailAssignment.java | 3 +- .../tuwien/kr/alpha/core/common/RuleTest.java | 8 +- .../core/grounder/NaiveGrounderTest.java | 38 +++--- .../core/grounder/NoGoodGeneratorTest.java | 4 +- .../kr/alpha/core/grounder/UnifierTest.java | 4 +- .../alpha/core/parser/AspCore2ParserTest.java | 4 +- .../kr/alpha/core/parser/ParserTest.java | 32 ++--- .../alpha/core/programs/atoms/AtomsTest.java | 30 ++--- .../ProgramTransformationTest.java | 6 +- .../StratifiedEvaluationRegressionTest.java | 4 +- .../alpha/core/solver/ChoiceManagerTests.java | 4 +- .../tuwien/kr/alpha/test/AlphaAssertions.java | 13 +- .../kr/alpha/api/impl/AlphaFactory.java | 52 +++----- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 124 +++++++++--------- .../tuwien/kr/alpha/api/impl/TestRunner.java | 6 +- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 39 +++--- .../alpha/AggregateRewritingContextTest.java | 4 +- .../kr/alpha/AggregateRewritingTest.java | 4 +- .../at/ac/tuwien/kr/alpha/RuleParser.java | 4 +- .../ac/tuwien/kr/alpha/RuleToStringTest.java | 4 +- .../kr/alpha/StratifiedEvaluationTest.java | 6 +- .../kr/alpha/api/impl/AlphaImplTest.java | 108 +++++++-------- .../alpha/regressiontests/HanoiTowerTest.java | 8 +- .../HeadBodyTransformationTests.java | 4 +- .../regressiontests/OmigaBenchmarksTest.java | 4 +- .../kr/alpha/regressiontests/RacksTest.java | 4 +- .../kr/alpha/regressiontests/SolverTests.java | 4 +- .../ThreeColouringRandomGraphTest.java | 12 +- .../ThreeColouringTestWithRandom.java | 10 +- .../ThreeColouringWheelTest.java | 12 +- 83 files changed, 680 insertions(+), 769 deletions(-) rename alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/{ASPCore2ProgramImpl.java => InputProgramImpl.java} (86%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{aspcore2/ASPCore2ParseTreeVisitor.java => ParseTreeVisitor.java} (95%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/{aspcore2/ASPCore2ProgramPartParser.java => ProgramPartParser.java} (88%) delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{EnumerationTransformer.java => EnumerationRewriting.java} (87%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{IntervalTermTransformer.java => IntervalTermToIntervalAtom.java} (98%) delete mode 100644 alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{ProgramTransformer.java => ProgramTransformation.java} (57%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/{VariableEqualityTransformer.java => VariableEqualityRemoval.java} (91%) rename alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/{AggregateTransformer.java => AggregateRewriting.java} (84%) diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/AggregateRewritingConfig.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/AggregateRewritingConfig.java index 6c72fbe62..908b2b3cb 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/AggregateRewritingConfig.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/AggregateRewritingConfig.java @@ -5,7 +5,7 @@ /** * Configuration structure controlling how {@link AggregateLiteral}s are compiled during program normalization in - * {@link Alpha#normalizeProgram(at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program)}. + * {@link Alpha#normalizeProgram(at.ac.tuwien.kr.alpha.api.programs.InputProgram)}. * * Copyright (c) 2021, the Alpha Team. */ diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java index f9fe5122f..7c3df5bf8 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java @@ -8,9 +8,9 @@ public interface InputProgram extends Program> { - /** - * The test cases associated with this program. - */ - List getTestCases(); + /** + * The test cases associated with this program. + */ + List getTestCases(); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java index 5b0ab32e1..240a3b232 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/actions/Action.java @@ -1,9 +1,9 @@ package at.ac.tuwien.kr.alpha.api.programs.actions; -import java.util.List; +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import java.util.List; /** * An action that gets executed as part of an action rule in an evolog program firing. diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java index 8f2d8ebc8..92bdc6776 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/NormalRule.java @@ -14,4 +14,6 @@ default BasicAtom getHeadAtom() { return this.isConstraint() ? null : this.getHead().getAtom(); } + boolean isGround(); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java index 74646f00d..7a36f19db 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java @@ -6,6 +6,6 @@ public interface RuleInstantiator { - BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution); + BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java index 744531317..9956ccee8 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java @@ -7,10 +7,10 @@ public interface ActionHead extends NormalHead { - String getActionName(); + String getActionName(); - List getActionInputTerms(); + List getActionInputTerms(); - VariableTerm getActionOutputTerm(); + VariableTerm getActionOutputTerm(); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java index 82aa89343..32dcca689 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java @@ -6,6 +6,6 @@ public interface InstantiableHead extends Head { - BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution); + BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java index 28fc53769..5436abf0f 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java @@ -1,30 +1,30 @@ package at.ac.tuwien.kr.alpha.api.programs.terms; - /** - * A term representing the result of an evolog action (i.e. result of action function application). - * Action result terms are function terms with symbol "success" or "error" depending on whether the corresponding action was sucessful. - * There is always one argument which is either some term representing the actual function result or an error message, respectively. - */ +/** + * A term representing the result of an evolog action (i.e. result of action function application). + * Action result terms are function terms with symbol "success" or "error" depending on whether the corresponding action was sucessful. + * There is always one argument which is either some term representing the actual function result or an error message, respectively. + */ public interface ActionResultTerm extends FunctionTerm { - public static final String SUCCESS_SYMBOL = "success"; - public static final String ERROR_SYMBOL = "error"; + public static final String SUCCESS_SYMBOL = "success"; + public static final String ERROR_SYMBOL = "error"; - /** - * True if the action that generated this result was successful (i.e. executed normally). - */ - boolean isSuccess(); + /** + * True if the action that generated this result was successful (i.e. executed normally). + */ + boolean isSuccess(); - /** - * True if the action that generated this result failed (i.e. threw an error in execution). - */ - boolean isError(); + /** + * True if the action that generated this result failed (i.e. threw an error in execution). + */ + boolean isError(); - /** - * Gets the actual value wrapped in this result. - * Either a term representing the action return value or a string term representing an error - * message.s - */ - T getValue(); + /** + * Gets the actual value wrapped in this result. + * Either a term representing the action return value or a string term representing an error + * message.s + */ + T getValue(); } \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/Externals.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/Externals.java index aa9153e95..52066fd09 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/Externals.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/Externals.java @@ -23,19 +23,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.externals; - -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.reflections.Reflections; -import org.reflections.scanners.MethodAnnotationsScanner; +package at.ac.tuwien.kr.alpha.commons.externals; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; @@ -44,13 +32,11 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.BinaryPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.BindingMethodPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.IntPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.LongPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.MethodPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.SuppliedPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.UnaryPredicateInterpretation; +import org.reflections.Reflections; +import org.reflections.scanners.MethodAnnotationsScanner; + +import java.lang.reflect.Method; +import java.util.*; public final class Externals { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/PredicateInterpretationImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/PredicateInterpretationImpl.java index 8e52bfacb..5ff6c5cfe 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/PredicateInterpretationImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/externals/PredicateInterpretationImpl.java @@ -1,11 +1,12 @@ package at.ac.tuwien.kr.alpha.commons.externals; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; + import java.util.List; import java.util.Set; -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; // TODO this looks like a duplicate public interface PredicateInterpretationImpl extends PredicateInterpretation { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InputProgramImpl.java similarity index 86% rename from alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java rename to alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InputProgramImpl.java index c67097ed3..64c3c5a3c 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/InputProgramImpl.java @@ -44,13 +44,13 @@ * Copyright (c) 2017-2019, the Alpha Team. */ // TODO rename this to InputProgramImpl or some such -class ASPCore2ProgramImpl extends AbstractProgram> implements InputProgram { +class InputProgramImpl extends AbstractProgram> implements InputProgram { - static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl(), Collections.emptyList()); + static final InputProgramImpl EMPTY = new InputProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl(), Collections.emptyList()); private final List testCases; - ASPCore2ProgramImpl(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { + InputProgramImpl(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { super(rules, facts, inlineDirectives); this.testCases = testCases; } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java index 460231815..0a10b61d7 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -4,9 +4,8 @@ import java.util.Collections; import java.util.List; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; -import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; @@ -22,25 +21,25 @@ private Programs() { } public static InputProgram emptyProgram() { - return ASPCore2ProgramImpl.EMPTY; + return InputProgramImpl.EMPTY; } // TODO rename method - public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { - return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, testCases); + public static InputProgram newInputProgram(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { + return new InputProgramImpl(rules, facts, inlineDirectives, testCases); } // TODO rename method - public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { - return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, Collections.emptyList()); + public static InputProgram newInputProgram(List> rules, List facts, InlineDirectives inlineDirectives) { + return new InputProgramImpl(rules, facts, inlineDirectives, Collections.emptyList()); } - public static ASPCore2ProgramBuilder builder() { - return new ASPCore2ProgramBuilder(); + public static InputProgramBuilder builder() { + return new InputProgramBuilder(); } - public static ASPCore2ProgramBuilder builder(InputProgram program) { - return new ASPCore2ProgramBuilder(program); + public static InputProgramBuilder builder(InputProgram program) { + return new InputProgramBuilder(program); } public static NormalProgram newNormalProgram(List rules, List facts, InlineDirectives inlineDirectives) { @@ -60,10 +59,10 @@ public static InlineDirectives newInlineDirectives() { } /** - * Builder for more complex program construction scenarios, ensuring that an {@link ASPCore2ProgramImpl} is immutable + * Builder for more complex program construction scenarios, ensuring that an {@link InputProgramImpl} is immutable */ // TODO maybe rename - public static class ASPCore2ProgramBuilder { + public static class InputProgramBuilder { private List> rules = new ArrayList<>(); private List facts = new ArrayList<>(); @@ -71,58 +70,58 @@ public static class ASPCore2ProgramBuilder { private List testCases = new ArrayList<>(); - public ASPCore2ProgramBuilder(InputProgram prog) { + public InputProgramBuilder(InputProgram prog) { this.addRules(prog.getRules()); this.addFacts(prog.getFacts()); this.addInlineDirectives(prog.getInlineDirectives()); this.addTestCases(prog.getTestCases()); } - public ASPCore2ProgramBuilder() { + public InputProgramBuilder() { } - public ASPCore2ProgramBuilder addRules(List> rules) { + public InputProgramBuilder addRules(List> rules) { this.rules.addAll(rules); return this; } - public ASPCore2ProgramBuilder addRule(Rule r) { + public InputProgramBuilder addRule(Rule r) { this.rules.add(r); return this; } - public ASPCore2ProgramBuilder addFacts(List facts) { + public InputProgramBuilder addFacts(List facts) { this.facts.addAll(facts); return this; } - public ASPCore2ProgramBuilder addFact(Atom fact) { + public InputProgramBuilder addFact(Atom fact) { this.facts.add(fact); return this; } - public ASPCore2ProgramBuilder addInlineDirectives(InlineDirectives inlineDirectives) { + public InputProgramBuilder addInlineDirectives(InlineDirectives inlineDirectives) { this.inlineDirectives.accumulate(inlineDirectives); return this; } - public ASPCore2ProgramBuilder addTestCase(TestCase testCase) { + public InputProgramBuilder addTestCase(TestCase testCase) { this.testCases.add(testCase); return this; } - public ASPCore2ProgramBuilder addTestCases(List testCases) { + public InputProgramBuilder addTestCases(List testCases) { this.testCases.addAll(testCases); return this; } - public ASPCore2ProgramBuilder accumulate(InputProgram prog) { + public InputProgramBuilder accumulate(InputProgram prog) { return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()).addTestCases(prog.getTestCases()); } public InputProgram build() { - return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives, this.testCases); + return Programs.newInputProgram(this.rules, this.facts, this.inlineDirectives, this.testCases); } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java index dba92f359..c21c7e0cb 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/reification/Reifier.java @@ -6,8 +6,8 @@ import java.util.function.Supplier; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; @@ -35,6 +35,7 @@ import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; +// TODO add support for action rules public class Reifier { // Predicates describing rules. @@ -193,7 +194,7 @@ public Reifier(Supplier>> idGeneratorProvider) { this.idGeneratorProvider = idGeneratorProvider; } - public Set reifyProgram(ASPCore2Program program) { + public Set reifyProgram(InputProgram program) { ReificationContext ctx = new ReificationContext(idGeneratorProvider.get()); reifyDirectives(ctx, program.getInlineDirectives()); for (Atom fact : program.getFacts()) { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java index 9326cad6b..5b8e4454e 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java @@ -26,7 +26,7 @@ public abstract class AbstractRule implements Rule { private final Set bodyLiteralsPositive; private final Set bodyLiteralsNegative; - public AbstractRule(H head, List body) { + public AbstractRule(H head, Set body) { this.head = head; Set positiveBody = new LinkedHashSet<>(); Set negativeBody = new LinkedHashSet<>(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java index e2bd1e178..13b991506 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java @@ -28,6 +28,7 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -38,7 +39,7 @@ */ class BasicRule extends AbstractRule { - BasicRule(Head head, List body) { + BasicRule(Head head, Set body) { super(head, body); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java index 828560f6f..80225ef71 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; @@ -14,8 +15,21 @@ */ class NormalRuleImpl extends AbstractRule implements NormalRule { - NormalRuleImpl(NormalHead head, List body) { + NormalRuleImpl(NormalHead head, Set body) { super(head, body); } + @Override + public boolean isGround() { + if (!isConstraint() && !this.getHead().isGround()) { + return false; + } + for (Literal bodyElement : this.getBody()) { + if (!bodyElement.isGround()) { + return false; + } + } + return true; + } + } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index 3d04c53f9..f0456caba 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,8 +1,6 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; +import java.util.*; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -19,21 +17,21 @@ private Rules() { throw new AssertionError("Cannot instantiate utility class!"); } - public static Rule newRule(Head head, List body) { + public static Rule newRule(Head head, Set body) { return new BasicRule(head, body); } public static Rule newRule(Head head, Literal... body) { - List bodyLst = new ArrayList<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new BasicRule(head, bodyLst); } - public static NormalRule newNormalRule(NormalHead head, List body) { + public static NormalRule newNormalRule(NormalHead head, Set body) { return new NormalRuleImpl(head, body); } public static NormalRule newNormalRule(NormalHead head, Literal... body) { - List bodyLst = new ArrayList<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new NormalRuleImpl(head, bodyLst); } @@ -45,7 +43,7 @@ public static NormalRule toNormalRule(Rule rule) { } headAtom = ((NormalHead) rule.getHead()).getAtom(); } - return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new ArrayList<>(rule.getBody())); + return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new LinkedHashSet<>(rule.getBody())); } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java index b7f95a5e6..a62753c8e 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/AssertionImpl.java @@ -1,14 +1,14 @@ package at.ac.tuwien.kr.alpha.commons.programs.tests; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; class AssertionImpl implements Assertion { private final Mode mode; - private final ASPCore2Program verifier; + private final InputProgram verifier; - AssertionImpl(final Mode mode, final ASPCore2Program verifier) { + AssertionImpl(final Mode mode, final InputProgram verifier) { this.mode = mode; this.verifier = verifier; } @@ -19,7 +19,7 @@ public Mode getMode() { } @Override - public ASPCore2Program getVerifier() { + public InputProgram getVerifier() { return verifier; } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java index 3962e5684..a750dc7c4 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/tests/Tests.java @@ -7,7 +7,7 @@ import java.util.function.IntPredicate; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; @@ -24,7 +24,7 @@ public static TestCase newTestCase(final String name, final IntPredicate answerS return new TestCaseImpl(name, answerSetCountVerifier, input, assertions); } - public static Assertion newAssertion(final Assertion.Mode mode, final ASPCore2Program verifier) { + public static Assertion newAssertion(final Assertion.Mode mode, final InputProgram verifier) { return new AssertionImpl(mode, verifier); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java index 22707f3ed..c23352dbd 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/AbstractActionImplementationProvider.java @@ -1,23 +1,19 @@ package at.ac.tuwien.kr.alpha.core.actions; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.OutputStream; +import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.programs.actions.Action; +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; + +import java.io.*; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.actions.Action; -import at.ac.tuwien.kr.alpha.api.terms.ActionResultTerm; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; - public abstract class AbstractActionImplementationProvider implements ActionImplementationProvider { private final IntIdGenerator idGenerator = new IntIdGenerator(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java index 5e3949519..ef5d8daa6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionService.java @@ -1,9 +1,9 @@ package at.ac.tuwien.kr.alpha.core.actions; -import java.util.List; - +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; + +import java.util.List; public interface ActionExecutionService { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java index 2952f7f26..4067e2182 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionExecutionServiceImpl.java @@ -4,10 +4,10 @@ import java.util.List; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.actions.Action; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; public class ActionExecutionServiceImpl implements ActionExecutionService { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java index a81bf4301..265780719 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/actions/ActionWitness.java @@ -1,9 +1,9 @@ package at.ac.tuwien.kr.alpha.core.actions; -import java.util.List; - import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; + +import java.util.List; public class ActionWitness { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java similarity index 95% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index b9e2cc758..610df11ad 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -30,8 +30,8 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.*; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; @@ -47,7 +47,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -76,8 +76,8 @@ public class ParseTreeVisitor extends ASPCore2BaseVisitor { * Therefore, have a stack onto which we "park" a program builder for the outer scope (i.e. main program) * while we parse the inner scope (i.e. test verifier). */ - private ASPCore2ProgramBuilder currentLevelProgramBuilder; - private Stack programBuilders = new Stack<>(); + private InputProgramBuilder currentLevelProgramBuilder; + private Stack programBuilders = new Stack<>(); public ParseTreeVisitor(Map externals) { this(externals, true); @@ -95,7 +95,7 @@ private UnsupportedOperationException notSupported(RuleContext ctx) { /** * Translates a program context (referring to a node in an ATN specific to ANTLR) to the internal representation of Alpha. */ - public ASPCore2Program translate(ASPCore2Parser.ProgramContext input) { + public InputProgram translate(ASPCore2Parser.ProgramContext input) { return visitProgram(input); } @@ -145,7 +145,7 @@ public String visitTerminal(TerminalNode node) { } @Override - public ASPCore2Program visitProgram(ASPCore2Parser.ProgramContext ctx) { + public InputProgram visitProgram(ASPCore2Parser.ProgramContext ctx) { // program : statements? query?; if (ctx.query() != null) { throw notSupported(ctx.query()); @@ -178,7 +178,7 @@ public Object visitStatement_fact(ASPCore2Parser.Statement_factContext ctx) { currentLevelProgramBuilder.addFact(((NormalHead) head).getAtom()); } else { // Treat facts with choice or disjunction in the head like a rule. - currentLevelProgramBuilder.addRule(Rules.newRule(head, Collections.emptyList())); + currentLevelProgramBuilder.addRule(Rules.newRule(head, Collections.emptySet())); } return null; } @@ -247,6 +247,15 @@ public Head visitChoice(ASPCore2Parser.ChoiceContext ctx) { return Heads.newChoiceHead(visitChoice_elements(ctx.choice_elements()), lt, lop, ut, uop); } + @Override + public Head visitAction(ASPCore2Parser.ActionContext ctx) { + BasicAtom atom = visitClassical_literal(ctx.classical_literal()); + VariableTerm actionResultTerm = visitVariable_term(ctx.variable_term()); + String actionId = ctx.ID().getText(); + List actionInputTerms = visitTerms(ctx.terms()); + return Heads.newActionHead(atom, actionId, actionInputTerms, actionResultTerm); + } + @Override public List visitChoice_elements(ASPCore2Parser.Choice_elementsContext ctx) { // choice_elements : choice_element (SEMICOLON choice_elements)?; @@ -312,13 +321,13 @@ public Object visitDirective_test(ASPCore2Parser.Directive_testContext ctx) { } @Override - public List visitBody(ASPCore2Parser.BodyContext ctx) { + public Set visitBody(ASPCore2Parser.BodyContext ctx) { // body : ( naf_literal | aggregate ) (COMMA body)?; if (ctx == null) { - return Collections.emptyList(); + return Collections.emptySet(); } - final List literals = new ArrayList<>(); + final Set literals = new LinkedHashSet<>(); do { if (ctx.naf_literal() != null) { literals.add(visitNaf_literal(ctx.naf_literal())); @@ -409,7 +418,7 @@ public Term visitGround_term(ASPCore2Parser.Ground_termContext ctx) { } @Override - public Term visitVariable_term(ASPCore2Parser.Variable_termContext ctx) { + public VariableTerm visitVariable_term(ASPCore2Parser.Variable_termContext ctx) { // variable_term : VARIABLE | ANONYMOUS_VARIABLE; if (ctx.VARIABLE() != null) { return Terms.newVariable(ctx.VARIABLE().getText()); @@ -698,11 +707,11 @@ public Assertion visitTestVerifier(Assertion.Mode assertionMode, ASPCore2Parser. } List stmts = ctx.statement(); programBuilders.push(currentLevelProgramBuilder); - currentLevelProgramBuilder = new ASPCore2ProgramBuilder(); + currentLevelProgramBuilder = new InputProgramBuilder(); for (ASPCore2Parser.StatementContext stmtCtx : stmts) { visit(stmtCtx); } - ASPCore2Program verifier = currentLevelProgramBuilder.build(); + InputProgram verifier = currentLevelProgramBuilder.build(); currentLevelProgramBuilder = programBuilders.pop(); return Tests.newAssertion(assertionMode, verifier); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java index 64e36c247..4c4d418ce 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java @@ -8,6 +8,9 @@ import java.util.Map; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; +import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; +import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import org.antlr.v4.runtime.BailErrorStrategy; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; @@ -20,8 +23,8 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; public class ProgramParserImpl implements ProgramParser { @@ -35,6 +38,12 @@ public ProgramParserImpl(Map externals) { this(); this.preloadedExternals.putAll(externals); } + + public ProgramParserImpl(ActionImplementationProvider actionImplementationProvider, Map externals) { + this(externals); + this.preloadedExternals.put("stdin", actionImplementationProvider.getStdinTerm()); + this.preloadedExternals.put("stdout", actionImplementationProvider.getStdoutTerm()); + } @Override public InputProgram parse(String s) { @@ -141,7 +150,7 @@ public InputProgram parse(Path programPath, Map @Override public InputProgram parse(Map externalPredicateDefinitions, Path... programSources) throws IOException { - ASPCore2ProgramBuilder bld = Programs.builder(); + InputProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); } @@ -150,7 +159,7 @@ public InputProgram parse(Map externalPredicate @Override public InputProgram parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { - ASPCore2ProgramBuilder bld = Programs.builder(); + InputProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java similarity index 88% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java index 255a58891..14a5bc1d9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramPartParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java @@ -26,7 +26,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.parser.aspcore2; +package at.ac.tuwien.kr.alpha.core.parser; import java.util.Collections; @@ -41,15 +41,14 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; -import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; /** - * A parser that, in contrast to {@link AbstractProgramParser}, does not parse full programs but only program parts like + * A parser that, in contrast to {@link ProgramParser}, does not parse full programs but only program parts like * atoms, terms and such. */ // TODO adapt this and create evolog version -public class ASPCore2ProgramPartParser { - private final ASPCore2ParseTreeVisitor visitor = new ASPCore2ParseTreeVisitor(Collections.emptyMap(), true); +public class ProgramPartParser { + private final ParseTreeVisitor visitor = new ParseTreeVisitor(Collections.emptyMap(), true); public Term parseTerm(String s) { final ASPCore2Parser parser = getASPCore2Parser(s); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java deleted file mode 100644 index c4cd13ea7..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/aspcore2/ASPCore2ProgramParser.java +++ /dev/null @@ -1,23 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser.aspcore2; - -import java.util.Map; - -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; - -public class ASPCore2ProgramParser extends AbstractProgramParser { - - public ASPCore2ProgramParser() { - super(); - } - - public ASPCore2ProgramParser(Map externals) { - super(externals); - } - - @Override - protected ASPCore2ParseTreeVisitor createParseTreeVisitor(Map externals) { - return new ASPCore2ParseTreeVisitor(externals); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java deleted file mode 100644 index 2093d5da1..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologParseTreeVisitor.java +++ /dev/null @@ -1,34 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser.evolog; - -import java.util.List; -import java.util.Map; - -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ParseTreeVisitor; - -public class EvologParseTreeVisitor extends ASPCore2ParseTreeVisitor { - - public EvologParseTreeVisitor(Map externals, boolean acceptVariables) { - super(externals, acceptVariables); - } - - public EvologParseTreeVisitor(Map externals) { - this(externals, true); - } - - @Override - public Head visitAction(ASPCore2Parser.ActionContext ctx) { - BasicAtom atom = visitClassical_literal(ctx.classical_literal()); - VariableTerm actionResultTerm = visitVariable_term(ctx.variable_term()); - String actionId = ctx.ID().getText(); - List actionInputTerms = visitTerms(ctx.terms()); - return Heads.newActionHead(atom, actionId, actionInputTerms, actionResultTerm); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java deleted file mode 100644 index 3b1a9f71c..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/evolog/EvologProgramParser.java +++ /dev/null @@ -1,27 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser.evolog; - -import java.util.Collections; -import java.util.Map; - -import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; -import at.ac.tuwien.kr.alpha.core.parser.AbstractProgramParser; - -public class EvologProgramParser extends AbstractProgramParser { - - public EvologProgramParser(ActionImplementationProvider actionImplementationProvider, Map externals) { - super(externals); - registerExternal("stdin", actionImplementationProvider.getStdinTerm()); - registerExternal("stdout", actionImplementationProvider.getStdoutTerm()); - } - - public EvologProgramParser(ActionImplementationProvider actionImplementationProvider) { - this(actionImplementationProvider, Collections.emptyMap()); - } - - @Override - protected EvologParseTreeVisitor createParseTreeVisitor(Map externals) { - return new EvologParseTreeVisitor(externals); - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java index 43e69b984..afd2236ab 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/InternalProgram.java @@ -104,7 +104,7 @@ public Map getRulesById() { public NormalProgram toNormalProgram() { List normalRules = new ArrayList<>(); for (CompiledRule rule : getRules()) { - normalRules.add(Rules.newNormalRule(rule.getHead(), new ArrayList<>(rule.getBody()))); + normalRules.add(Rules.newNormalRule(rule.getHead(), new LinkedHashSet<>(rule.getBody()))); } return Programs.newNormalProgram(normalRules, getFacts(), getInlineDirectives()); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index 8b57907f2..1bc31f104 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -43,7 +43,9 @@ import com.google.common.annotations.VisibleForTesting; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; /** * Represents a normal rule or a constraint for the semi-naive grounder. @@ -67,7 +69,7 @@ public class InternalRule extends AbstractRule implements CompiledRu * @param head the head of the rule. * @param body the list of body literals of the rule. */ - public InternalRule(NormalHead head, List body) { + public InternalRule(NormalHead head, Set body) { super(head, body); if (body.isEmpty()) { throw new IllegalArgumentException( @@ -101,7 +103,7 @@ public static void resetIdGenerator() { } public static CompiledRule fromNormalRule(Rule rule) { - return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new ArrayList<>(rule.getBody())); + return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new LinkedHashSet<>(rule.getBody())); } /** @@ -126,7 +128,7 @@ public InternalRule renameVariables(String newVariablePostfix) { variableReplacement.put(occurringVariable, Terms.newVariable(newVariableName)); } BasicAtom renamedHeadAtom = headAtom.substitute(variableReplacement); - ArrayList renamedBody = new ArrayList<>(this.getBody().size()); + Set renamedBody = new LinkedHashSet<>(this.getBody().size()); for (Literal literal : this.getBody()) { renamedBody.add(literal.substitute(variableReplacement)); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index 029123628..d7111f098 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -1,7 +1,9 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -70,7 +72,7 @@ public NormalProgram apply(NormalProgram inputProgram) { private NormalRule rewriteRule(NormalRule inputProgramRule) { variableNumberGenerator.resetGenerator(); // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; - List rewrittenBodyLiterals = new ArrayList<>(); + Set rewrittenBodyLiterals = new LinkedHashSet<>(); // Rewrite head. if (!inputProgramRule.isConstraint()) { BasicAtom headAtom = inputProgramRule.getHeadAtom(); @@ -117,7 +119,7 @@ private boolean containsArithmeticTermsToRewrite(NormalRule inputProgramRule) { return false; } - private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { + private Term rewriteArithmeticSubterms(Term term, Set bodyLiterals) { // Keep term as-is if it contains no ArithmeticTerm. if (!containsArithmeticTerm(term)) { return term; @@ -141,7 +143,7 @@ private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { } } - private Atom rewriteAtom(Atom atomToRewrite, List bodyLiterals) { + private Atom rewriteAtom(Atom atomToRewrite, Set bodyLiterals) { if (atomToRewrite instanceof ComparisonAtom) { throw Util.oops("Trying to rewrite ComparisonAtom."); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 486c57e12..3b167ac9f 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -27,11 +27,8 @@ */ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; +import java.util.*; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -44,7 +41,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; @@ -59,7 +56,7 @@ public class ChoiceHeadToNormal extends ProgramTransformation> additionalRules = new ArrayList<>(); List> srcRules = new ArrayList<>(inputProgram.getRules()); @@ -105,11 +102,11 @@ public InputProgram apply(InputProgram inputProgram) { BasicAtom negHead = Atoms.newBasicAtom(negPredicate, headTerms); // Construct two guessing rules. - List guessingRuleBodyWithNegHead = new ArrayList<>(ruleBody); + Set guessingRuleBodyWithNegHead = new LinkedHashSet<>(ruleBody); guessingRuleBodyWithNegHead.add(Atoms.newBasicAtom(head.getPredicate(), head.getTerms()).toLiteral(false)); additionalRules.add(Rules.newRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead)); - List guessingRuleBodyWithHead = new ArrayList<>(ruleBody); + Set guessingRuleBodyWithHead = new LinkedHashSet<>(ruleBody); guessingRuleBodyWithHead.add(Atoms.newBasicAtom(negPredicate, headTerms).toLiteral(false)); additionalRules.add(Rules.newRule(Heads.newNormalHead(head), guessingRuleBodyWithHead)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java similarity index 87% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java index 9d20fb69f..803af1879 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/EnumerationRewriting.java @@ -1,12 +1,9 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; +import java.util.*; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.BasicLiteral; @@ -18,7 +15,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; @@ -30,10 +27,10 @@ * Copyright (c) 2017-2020, the Alpha Team. */ // TODO this should happen during/after internalization -public class EnumerationRewriting extends ProgramTransformation { +public class EnumerationRewriting extends ProgramTransformation { @Override - public ASPCore2Program apply(ASPCore2Program inputProgram) { + public InputProgram apply(InputProgram inputProgram) { // Read enumeration predicate from directive. String enumDirective = inputProgram.getInlineDirectives().getDirectiveValue(InlineDirectives.DIRECTIVE.enum_predicate_is); if (enumDirective == null) { @@ -42,7 +39,7 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { } Predicate enumPredicate = Predicates.getPredicate(enumDirective, 3); - ASPCore2ProgramBuilder programBuilder = Programs.builder().addInlineDirectives(inputProgram.getInlineDirectives()); + InputProgramBuilder programBuilder = Programs.builder().addInlineDirectives(inputProgram.getInlineDirectives()); checkFactsAreEnumerationFree(inputProgram.getFacts(), enumPredicate); programBuilder.addFacts(inputProgram.getFacts()); @@ -69,7 +66,7 @@ private List> rewriteRules(List> srcRules, Predicate enumP if (rule.getHead() != null && ((NormalHead) rule.getHead()).getAtom().getPredicate().equals(enumPredicate)) { throw Util.oops("Atom declared as enumeration atom by directive occurs in head of the rule: " + rule); } - List modifiedBodyLiterals = new ArrayList<>(rule.getBody()); + Set modifiedBodyLiterals = new LinkedHashSet<>(rule.getBody()); Iterator rit = modifiedBodyLiterals.iterator(); LinkedList rewrittenLiterals = new LinkedList<>(); while (rit.hasNext()) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java similarity index 98% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 90d532aff..9b1c69143 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -27,10 +27,7 @@ */ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -68,7 +65,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { // Collect all intervals and replace them with variables. Map intervalReplacements = new LinkedHashMap<>(); - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal literal : rule.getBody()) { Literal rewrittenLiteral = rewriteLiteral(literal, intervalReplacements); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java index f8d3303f0..d3b5c9cc8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/NormalizeProgramTransformation.java @@ -1,7 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; import at.ac.tuwien.kr.alpha.api.config.AggregateRewritingConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.core.programs.atoms.EnumerationAtom; @@ -12,7 +12,7 @@ * * Copyright (c) 2019-2021, the Alpha Team. */ -public class NormalizeProgramTransformation extends ProgramTransformation { +public class NormalizeProgramTransformation extends ProgramTransformation { private final AggregateRewritingConfig aggregateRewritingCfg; @@ -21,8 +21,8 @@ public NormalizeProgramTransformation(AggregateRewritingConfig aggregateCfg) { } @Override - public NormalProgram apply(ASPCore2Program inputProgram) { - ASPCore2Program tmpPrg; + public NormalProgram apply(InputProgram inputProgram) { + InputProgram tmpPrg; // Remove variable equalities. tmpPrg = new VariableEqualityRemoval().apply(inputProgram); // Transform choice rules. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index 23b47bc83..d33962805 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -1,9 +1,6 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.List; - -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -14,11 +11,16 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + /** * * Rewrites all predicates of a given Program such that they are internal and hence hidden from answer sets. @@ -27,8 +29,8 @@ */ public class PredicateInternalizer { - public static ASPCore2Program makePrefixedPredicatesInternal(ASPCore2Program program, String prefix) { - ASPCore2ProgramBuilder prgBuilder = Programs.builder(); + public static InputProgram makePrefixedPredicatesInternal(InputProgram program, String prefix) { + InputProgramBuilder prgBuilder = Programs.builder(); for (Atom atom : program.getFacts()) { if (atom.getPredicate().getName().startsWith(prefix)) { prgBuilder.addFact(PredicateInternalizer.makePredicateInternal((BasicAtom) atom)); @@ -56,7 +58,7 @@ public static Rule makePrefixedPredicatesInternal(Rule rule, String newHead = head; } } - List newBody = new ArrayList<>(); + Set newBody = new LinkedHashSet<>(); for (Literal bodyElement : rule.getBody()) { // Only rewrite BasicAtoms. if (bodyElement instanceof BasicLiteral) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java deleted file mode 100644 index 89498e3da..000000000 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramNormalizer.java +++ /dev/null @@ -1,54 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation; - -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.core.atoms.EnumerationAtom; -import at.ac.tuwien.kr.alpha.core.programs.NormalProgramImpl; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateTransformer; - -/** - * Encapsulates all transformations necessary to transform a given program into a @{link NormalProgram} that is understood by Alpha internally - * - * Copyright (c) 2019-2021, the Alpha Team. - */ -public class ProgramNormalizer extends ProgramTransformer { - - private final VariableEqualityTransformer equalityTransformer; - private final ChoiceHeadNormalizer choiceHeadNormalizer; - private final AggregateTransformer aggregateTransformer; - private final EnumerationTransformer enumerationTransformer; - private final IntervalTermTransformer intervalTermTransformer; - private final ArithmeticTermTransformer arithmeticTermTransformer; - - public ProgramNormalizer(VariableEqualityTransformer equalityTransformer, ChoiceHeadNormalizer choiceHeadNormalizer, AggregateTransformer aggregateTransformer, EnumerationTransformer enumerationTransformer, IntervalTermTransformer intervalTermTransformer, ArithmeticTermTransformer arithmeticTermTransformer) { - this.equalityTransformer = equalityTransformer; - this.choiceHeadNormalizer = choiceHeadNormalizer; - this.aggregateTransformer = aggregateTransformer; - this.enumerationTransformer = enumerationTransformer; - this.intervalTermTransformer = intervalTermTransformer; - this.arithmeticTermTransformer = arithmeticTermTransformer; - } - - @Override - public NormalProgram transform(InputProgram inputProgram) { - InputProgram tmpPrg; - // Remove variable equalities. - tmpPrg = equalityTransformer.transform(inputProgram); - // Transform choice rules. - tmpPrg = choiceHeadNormalizer.transform(tmpPrg); - // Transform aggregates. - tmpPrg = aggregateTransformer.transform(tmpPrg); - // Transform enumeration atoms. - tmpPrg = enumerationTransformer.transform(tmpPrg); - EnumerationAtom.resetEnumerations(); - - // Construct the normal program. - NormalProgram retVal = NormalProgramImpl.fromInputProgram(tmpPrg); - // Transform intervals. - retVal = intervalTermTransformer.transform(retVal); - // Rewrite ArithmeticTerms. - retVal = arithmeticTermTransformer.transform(retVal); - return retVal; - } - -} diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java similarity index 57% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java index 098c10bc8..5fc28c50a 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformation.java @@ -6,8 +6,8 @@ /** * Copyright (c) 2017-2019, the Alpha Team. */ -public abstract class ProgramTransformer>, O extends Program>> { +public abstract class ProgramTransformation>, O extends Program>> { - public abstract O transform(I inputProgram); + public abstract O apply(I inputProgram); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java index 34fed23dc..07bf0036e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluation.java @@ -11,6 +11,15 @@ import java.util.Set; import java.util.Stack; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.InstantiableHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.apache.commons.collections4.SetUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.slf4j.Logger; @@ -21,10 +30,13 @@ import at.ac.tuwien.kr.alpha.api.programs.analysis.ComponentGraph; import at.ac.tuwien.kr.alpha.api.programs.analysis.DependencyGraph; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; +import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionService; +import at.ac.tuwien.kr.alpha.core.actions.ActionWitness; import at.ac.tuwien.kr.alpha.core.depgraph.StratificationAlgorithm; import at.ac.tuwien.kr.alpha.core.grounder.IndexedInstanceStorage; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; @@ -36,14 +48,13 @@ import at.ac.tuwien.kr.alpha.core.grounder.instantiation.WorkingMemoryBasedInstantiationStrategy; import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; /** * Evaluates the stratifiable part of a given (analyzed) ASP program. - * + * * Copyright (c) 2019-2020, the Alpha Team. */ -public class StratifiedEvaluation extends ProgramTransformation { +public class StratifiedEvaluation extends ProgramTransformation implements RuleInstantiator { private static final Logger LOGGER = LoggerFactory.getLogger(StratifiedEvaluation.class); @@ -52,10 +63,17 @@ public class StratifiedEvaluation extends ProgramTransformation> modifiedInLastEvaluationRun = new HashMap<>(); - private List additionalFacts = new ArrayList<>(); // The additional facts derived by stratified evaluation. Note that it may contain duplicates. + private Set outputFacts = new HashSet<>(); // The additional facts derived by stratified evaluation. Note that it may contain duplicates. private Set solvedRuleIds = new HashSet<>(); // Set of rules that have been completely evaluated. private LiteralInstantiator literalInstantiator; + private ActionExecutionService actionExecutionService; + private final boolean generateActionWitnesses; + + public StratifiedEvaluation(ActionExecutionService actionExecutionService, boolean generateActionWitnesses) { + this.actionExecutionService = actionExecutionService; + this.generateActionWitnesses = generateActionWitnesses; + } @Override // Note: ideally this returns a "PartiallyEvaluatedProgram" such that the grounder can directly use the working @@ -82,6 +100,9 @@ public InternalProgram apply(AnalyzedProgram inputProgram) { workingMemory.reset(); + // Set up set of facts to which we'll add everything derived during stratified evaluation. + outputFacts = new HashSet<>(inputProgram.getFacts()); + // Set up literal instantiator. literalInstantiator = new LiteralInstantiator(new WorkingMemoryBasedInstantiationStrategy(workingMemory)); @@ -91,13 +112,12 @@ public InternalProgram apply(AnalyzedProgram inputProgram) { } // Build the program resulting from evaluating the stratified part. - additionalFacts.addAll(inputProgram.getFacts()); // Add original input facts to newly derived ones. List outputRules = new ArrayList<>(); inputProgram.getRulesById().entrySet().stream().filter((entry) -> !solvedRuleIds.contains(entry.getKey())) .forEach((entry) -> outputRules.add(entry.getValue())); // NOTE: if InternalProgram requires solved rules, they should be added here. - return new InternalProgram(outputRules, additionalFacts); + return new InternalProgram(outputRules, new ArrayList<>(outputFacts)); } private void evaluateComponent(ComponentGraph.SCComponent comp) { @@ -114,9 +134,7 @@ private void evaluateComponent(ComponentGraph.SCComponent comp) { evaluateRules(evaluationInfo.nonRecursiveRules, true); for (IndexedInstanceStorage instanceStorage : workingMemory.modified()) { // Directly record all newly derived instances as additional facts. - for (Instance recentlyAddedInstance : instanceStorage.getRecentlyAddedInstances()) { - additionalFacts.add(Atoms.newBasicAtom(instanceStorage.getPredicate(), recentlyAddedInstance.terms)); - } + recordRecentlyAddedInstances(instanceStorage); instanceStorage.markRecentlyAddedInstancesDone(); } } @@ -134,9 +152,7 @@ private void evaluateComponent(ComponentGraph.SCComponent comp) { // Since we are stratified we never have to backtrack, therefore just collect the added instances. for (IndexedInstanceStorage instanceStorage : workingMemory.modified()) { // Directly record all newly derived instances as additional facts. - for (Instance recentlyAddedInstance : instanceStorage.getRecentlyAddedInstances()) { - additionalFacts.add(Atoms.newBasicAtom(instanceStorage.getPredicate(), recentlyAddedInstance.terms)); - } + recordRecentlyAddedInstances(instanceStorage); modifiedInLastEvaluationRun.putIfAbsent(instanceStorage.getPredicate(), new LinkedHashSet<>()); modifiedInLastEvaluationRun.get(instanceStorage.getPredicate()).addAll(instanceStorage.getRecentlyAddedInstances()); instanceStorage.markRecentlyAddedInstancesDone(); @@ -149,6 +165,12 @@ private void evaluateComponent(ComponentGraph.SCComponent comp) { .forEach((rule) -> solvedRuleIds.add(rule.getRuleId())); } + private void recordRecentlyAddedInstances(IndexedInstanceStorage instanceStorage) { + for (Instance recentlyAddedInstance : instanceStorage.getRecentlyAddedInstances()) { + outputFacts.add(Atoms.newBasicAtom(instanceStorage.getPredicate(), recentlyAddedInstance.terms)); + } + } + private void evaluateRules(Set rules, boolean isInitialRun) { workingMemory.reset(); LOGGER.debug("Starting component evaluation run..."); @@ -225,7 +247,7 @@ private List calculateSatisfyingSubstitutionsForRule(CompiledRule * Use this to find initial substitutions for a starting literal when grounding a rule. * In order to avoid finding the same ground instantiations of rules again, only look at * modifiedInLastEvaluationRun to obtain instances. - * + * * @param lit the literal to substitute. * @return valid ground substitutions for the literal based on the recently added instances (i.e. instances derived in * the last evaluation run). @@ -255,7 +277,7 @@ private List calcSubstitutionsWithGroundingOrder(RuleGroundingOrde substitutionStack.push((ArrayList) startingSubstitutions); } else { substitutionStack.push(new ArrayList<>(startingSubstitutions)); // Copy startingSubstitutions into ArrayList. Note: mostly happens for empty or - // singleton lists. + // singleton lists. } int currentOrderPosition = 0; List fullSubstitutions = new ArrayList<>(); @@ -280,7 +302,7 @@ private List calcSubstitutionsWithGroundingOrder(RuleGroundingOrde } // Take one substitution from the top-list of the stack and try extending it. Substitution currentSubstitution = currentSubstitutions.remove(currentSubstitutions.size() - 1); // Work on last element (removing last element is - // O(1) for ArrayList). + // O(1) for ArrayList). LiteralInstantiationResult currentLiteralResult = literalInstantiator.instantiateLiteral(currentLiteral, currentSubstitution); if (currentLiteralResult.getType() == LiteralInstantiationResult.Type.CONTINUE) { // The currentSubstitution could be extended, push the extensions on the stack and continue working on them. @@ -297,7 +319,13 @@ private List calcSubstitutionsWithGroundingOrder(RuleGroundingOrde } private void fireRule(CompiledRule rule, Substitution substitution) { - Atom newAtom = rule.getHeadAtom().substitute(substitution); + // BasicAtom newAtom = this.instantiate(rule.getHead(), substitution); + BasicAtom newAtom; + if (rule.getHead() instanceof ActionHead) { + newAtom = instantiateActionHead((ActionHead) rule.getHead(), substitution, rule); + } else { + newAtom = instantiateNormalHead(rule.getHead(), substitution); + } if (!newAtom.isGround()) { throw new IllegalStateException("Trying to fire rule " + rule.toString() + " with incompatible substitution " + substitution.toString()); } @@ -305,6 +333,64 @@ private void fireRule(CompiledRule rule, Substitution substitution) { workingMemory.addInstance(newAtom, true); } + @Override + public BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution) { + return ruleHead.instantiate(this, substitution); + } + + // FIXME should be dispatched via visitor pattern + public BasicAtom instantiateNormalHead(NormalHead head, Substitution substitution) { + return head.getAtom().substitute(substitution); + } + + // FIXME should be dispatched via visitor pattern + public BasicAtom instantiateActionHead(ActionHead head, Substitution substitution, CompiledRule rule) { + List actionInput = head.getActionInputTerms(); + List substitutedInput = new ArrayList<>(); + // Substitute all variables in action input so that all input terms are ground. + for (Term inputTerm : actionInput) { + substitutedInput.add(inputTerm.substitute(substitution)); + } + // Delegate action execution to respective backend. + ActionWitness witness = actionExecutionService.execute(head.getActionName(), rule.getRuleId(), substitution, substitutedInput); + // If the according debug flag is set, convert witness to atom and add to facts. + if (generateActionWitnesses) { + BasicAtom witnessAtom = buildActionWitnessAtom(witness, rule); + // Note that this is a rather "sneaky" side-effect, + // but seems like overkill to do this structurally proper just for a debug feature. + workingMemory.addInstance(witnessAtom, true); + } + // We have an action result. Add it to the substitution as the substitute for the variable bound to the action so we're able to obtain the + // ground BasicAtom derived by the rule + substitution.put(head.getActionOutputTerm(), witness.getActionResult()); + return head.getAtom().substitute(substitution); + } + + private BasicAtom buildActionWitnessAtom(ActionWitness witness, CompiledRule rule) { + // Note that this methods should only ever be used for debugging! + // While action witnesses are used as a semantic concept in the evolog specification, + // they normally only exist implicitly. + + // Construct state term: create function terms from ground body literals. + List functionalizedBody = new ArrayList<>(); + for (Literal lit : rule.getBody()) { + Literal groundLit = lit.substitute(witness.getGroundSubstitution()); + FunctionTerm functionalizedLiteral = Terms.newFunctionTerm(groundLit.getPredicate().getName(), groundLit.getTerms()); + functionalizedBody.add(functionalizedLiteral); + } + FunctionTerm stateTerm = Terms.newFunctionTerm("state", functionalizedBody); + + // Construct input term: wrap action input terms into one function term. + FunctionTerm inputTerm = Terms.newFunctionTerm("input", witness.getActionInput()); + + // Return witness atom: put state and input terms together. + return Atoms.newBasicAtom(Predicates.getPredicate("action_witness", 4), + Terms.newConstant(witness.getActionName()), + stateTerm, + inputTerm, + witness.getActionResult()); + } + private ComponentEvaluationInfo getRulesToEvaluate(ComponentGraph.SCComponent comp) { Set nonRecursiveRules = new HashSet<>(); Set recursiveRules = new HashSet<>(); @@ -348,7 +434,7 @@ private ComponentEvaluationInfo getRulesToEvaluate(ComponentGraph.SCComponent co * dependency chain within that component, and non-recursive rules, i.e. rules where all body predicates occur in lower * strata. The reason for this grouping is that, when evaluating rules within a component, non-recursive rules only need * to be evaluated once, while recursive rules need to be evaluated until a fixed-point has been reached. - * + * * Copyright (c) 2020, the Alpha Team. */ private class ComponentEvaluationInfo { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java similarity index 91% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index 3c84b54a0..a08aac2e2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -27,17 +27,9 @@ */ package at.ac.tuwien.kr.alpha.core.programs.transformation; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; +import java.util.*; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -57,15 +49,15 @@ * * Copyright (c) 2017-2021, the Alpha Team. */ -public class VariableEqualityRemoval extends ProgramTransformation { +public class VariableEqualityRemoval extends ProgramTransformation { @Override - public ASPCore2Program apply(ASPCore2Program inputProgram) { + public InputProgram apply(InputProgram inputProgram) { List> rewrittenRules = new ArrayList<>(); for (Rule rule : inputProgram.getRules()) { rewrittenRules.add(findAndReplaceVariableEquality(rule)); } - return Programs.newASPCore2Program(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); + return Programs.newInputProgram(rewrittenRules, inputProgram.getFacts(), inputProgram.getInlineDirectives()); } private Rule findAndReplaceVariableEquality(Rule rule) { @@ -112,7 +104,7 @@ private Rule findAndReplaceVariableEquality(Rule rule) { return rule; } - List rewrittenBody = new ArrayList<>(rule.getBody()); + Set rewrittenBody = new LinkedHashSet<>(rule.getBody()); if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java index b959269d2..ed55537b0 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateLiteralSplitting.java @@ -1,8 +1,6 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; +import java.util.*; import org.apache.commons.lang3.tuple.ImmutablePair; @@ -66,17 +64,17 @@ private static List> splitAggregatesInRule(Rule sourceRule) { } } // Second, compute rule bodies of splitting result. - List commonBody = new ArrayList<>(commonBodyLiterals); + Set commonBody = new LinkedHashSet<>(commonBodyLiterals); commonBody.addAll(twoLiteralsSplitAggregates); - List> rewrittenBodies = new ArrayList<>(); + List> rewrittenBodies = new ArrayList<>(); rewrittenBodies.add(commonBody); // Initialize list of rules with the common body. // For n twoRulesSplitAggregates we need 2^n rules, so // for each of the n pairs in twoRulesSplitAggregates we duplicate the list of rewritten bodies. for (ImmutablePair ruleSplitAggregate : twoRulesSplitAggregates) { int numBodiesBeforeDuplication = rewrittenBodies.size(); for (int i = 0; i < numBodiesBeforeDuplication; i++) { - List originalBody = rewrittenBodies.get(i); - List duplicatedBody = new ArrayList<>(originalBody); + Set originalBody = rewrittenBodies.get(i); + Set duplicatedBody = new LinkedHashSet<>(originalBody); // Extend bodies of original and duplicate with splitting results. originalBody.add(ruleSplitAggregate.left); duplicatedBody.add(ruleSplitAggregate.right); @@ -85,7 +83,7 @@ private static List> splitAggregatesInRule(Rule sourceRule) { } // Third, turn computed bodies into rules again. List> rewrittenRules = new ArrayList<>(); - for (List rewrittenBody : rewrittenBodies) { + for (Set rewrittenBody : rewrittenBodies) { rewrittenRules.add(Rules.newRule(sourceRule.getHead(), rewrittenBody)); } return rewrittenRules; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java index 12e3273b6..8235c1364 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateOperatorNormalization.java @@ -1,8 +1,6 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; +import java.util.*; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; @@ -22,7 +20,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; /** - * Transforms an {@link AspCore2ProgramImpl} such that, for all aggregate (body-)literals, only the comparison operators "=" + * Transforms an {@link at.ac.tuwien.kr.alpha.api.programs.InputProgram} such that, for all aggregate (body-)literals, only the comparison operators "=" * and "<=" are used. * * Rewriting of "#count" and "#sum" aggregates is done using the following equivalences: @@ -41,7 +39,7 @@ * Note that input programs must only contain aggregate literals of form TERM OP #aggr{...} or #aggr{...} OP TERM, * i.e. with only * a left or right term and operator (but not both). When preprocessing programs, apply this transformation AFTER - * {@link at.ac.tuwien.kr.alpha.grounder.transformation.aggregates.AggregateLiteralSplitting}. + * {@link AggregateLiteralSplitting}. * * Copyright (c) 2020-2021, the Alpha Team. */ @@ -52,7 +50,7 @@ private AggregateOperatorNormalization() { } public static Rule normalize(Rule rule) { - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal lit : rule.getBody()) { rewrittenBody.addAll(rewriteLiteral(lit)); } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java similarity index 84% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java index aff59e893..48d4747c9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewriting.java @@ -1,14 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.lang3.tuple.ImmutablePair; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -16,22 +9,23 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AbstractAggregateEncoder; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.CountEncoder; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.MinMaxEncoder; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.SumEncoder; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AggregateEncoders; +import org.apache.commons.lang3.tuple.ImmutablePair; + +import java.util.*; /** * Rewrites {@link AggregateLiteral}s in programs to semantically equivalent, aggregate-free sub-programs. * * Copyright (c) 2020, the Alpha Team. */ -public class AggregateRewriting extends ProgramTransformation { +public class AggregateRewriting extends ProgramTransformation { private final AbstractAggregateEncoder countEqualsEncoder; private final AbstractAggregateEncoder countLessOrEqualEncoder; @@ -51,12 +45,12 @@ public class AggregateRewriting extends ProgramTransformation> outputRules = new ArrayList<>(); for (Rule inputRule : inputProgram.getRules()) { @@ -89,7 +83,7 @@ public ASPCore2Program apply(ASPCore2Program inputProgram) { } // Substitute AggregateLiterals with generated result literals. outputRules.addAll(rewriteRulesWithAggregates(ctx)); - ASPCore2ProgramBuilder resultBuilder = Programs.builder().addRules(outputRules).addFacts(inputProgram.getFacts()) + InputProgramBuilder resultBuilder = Programs.builder().addRules(outputRules).addFacts(inputProgram.getFacts()) .addInlineDirectives(inputProgram.getInlineDirectives()); // Add sub-programs deriving respective aggregate literals. for (Map.Entry, Set> aggToRewrite : ctx.getAggregateFunctionsToRewrite() @@ -138,7 +132,7 @@ private AbstractAggregateEncoder getEncoderForAggregateFunction(AggregateFunctio private static List> rewriteRulesWithAggregates(AggregateRewritingContext ctx) { List> rewrittenRules = new ArrayList<>(); for (Rule rule : ctx.getRulesWithAggregates()) { - List rewrittenBody = new ArrayList<>(); + Set rewrittenBody = new LinkedHashSet<>(); for (Literal lit : rule.getBody()) { if (lit instanceof AggregateLiteral) { AggregateInfo aggregateInfo = ctx.getAggregateInfo((AggregateLiteral) lit); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java index c7e3f2fc2..a1742b71d 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingContext.java @@ -1,19 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.stringtemplate.v4.ST; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; @@ -28,6 +14,12 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.stringtemplate.v4.ST; + +import java.util.*; + +import static at.ac.tuwien.kr.alpha.commons.util.Util.oops; /** * Holds all information about aggregate literals that need to be rewritten within a program. diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java index 1433f1665..9647fa444 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysis.java @@ -1,15 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.collections4.SetUtils; - import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -18,6 +8,9 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import org.apache.commons.collections4.SetUtils; + +import java.util.*; /** * Analyses a rule and records occurring aggregates and for each aggregate its global variables and its dependencies on diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java index 4b6c431b1..92a09f658 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AbstractAggregateEncoder.java @@ -1,13 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; - -import org.apache.commons.collections4.ListUtils; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; @@ -19,13 +13,20 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.programs.transformation.PredicateInternalizer; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.collections4.ListUtils; +import org.apache.commons.collections4.SetUtils; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; /** * Abstract base class for aggregate encoders. An aggregate encoder provides an encoding for a given aggregate literal, @@ -49,10 +50,10 @@ protected AbstractAggregateEncoder(AggregateFunctionSymbol aggregateFunctionToEn * Encodes all aggregate literals in the given set of aggregate referenced by the given {@link AggregateInfo}. * * @param aggregatesToEncode the aggregates to encode. - * @return all rules encoding the given aggregates as an {@link AspCore2ProgramImpl}. + * @return all rules encoding the given aggregates as an {@link InputProgram}. */ - public ASPCore2Program encodeAggregateLiterals(Set aggregatesToEncode) { - ASPCore2ProgramBuilder programBuilder = Programs.builder(); + public InputProgram encodeAggregateLiterals(Set aggregatesToEncode) { + InputProgramBuilder programBuilder = Programs.builder(); for (AggregateInfo aggregateInfo : aggregatesToEncode) { programBuilder.accumulate(encodeAggregateLiteral(aggregateInfo)); } @@ -65,7 +66,7 @@ public ASPCore2Program encodeAggregateLiterals(Set aggregatesToEn * @param aggregateToEncode * @return */ - public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { + public InputProgram encodeAggregateLiteral(AggregateInfo aggregateToEncode) { AggregateLiteral literalToEncode = aggregateToEncode.getLiteral(); if (literalToEncode.getAtom().getAggregateFunction() != this.aggregateFunctionToEncode) { throw new IllegalArgumentException( @@ -76,13 +77,13 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { + literalToEncode.getAtom().getAggregateFunction() + " with operator " + literalToEncode.getAtom().getLowerBoundOperator()); } String aggregateId = aggregateToEncode.getId(); - ASPCore2Program literalEncoding = PredicateInternalizer.makePrefixedPredicatesInternal(encodeAggregateResult(aggregateToEncode), aggregateId); + InputProgram literalEncoding = PredicateInternalizer.makePrefixedPredicatesInternal(encodeAggregateResult(aggregateToEncode), aggregateId); List> elementEncodingRules = new ArrayList<>(); for (AggregateElement elementToEncode : literalToEncode.getAtom().getAggregateElements()) { Rule elementRule = encodeAggregateElement(aggregateToEncode, elementToEncode); elementEncodingRules.add(PredicateInternalizer.makePrefixedPredicatesInternal(elementRule, aggregateId)); } - return Programs.newASPCore2Program(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), Programs.newInlineDirectives()); + return Programs.newInputProgram(ListUtils.union(literalEncoding.getRules(), elementEncodingRules), literalEncoding.getFacts(), Programs.newInlineDirectives()); } /** @@ -93,7 +94,7 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { * @param aggregateToEncode * @return */ - protected abstract ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode); + protected abstract InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode); /** * Encodes individual aggregate elements. For each aggregate element, a rule is created that fires for each tuple matching the element. @@ -105,7 +106,7 @@ public ASPCore2Program encodeAggregateLiteral(AggregateInfo aggregateToEncode) { protected Rule encodeAggregateElement(AggregateInfo aggregateInfo, AggregateElement element) { BasicAtom headAtom = buildElementRuleHead(aggregateInfo.getId(), element, aggregateInfo.getAggregateArguments()); return Rules.newRule(Heads.newNormalHead(headAtom), - ListUtils.union(element.getElementLiterals(), new ArrayList<>(aggregateInfo.getDependencies()))); + SetUtils.union(new LinkedHashSet<>(element.getElementLiterals()), new LinkedHashSet<>(aggregateInfo.getDependencies()))); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java index 55d6ca6af..686fed1f6 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java @@ -9,28 +9,28 @@ private AggregateEncoders() { throw new AssertionError("Cannot instantiate utility class!"); } - public static CountEncoder newCountEqualsEncoder(ProgramParser parser) { - return CountEncoder.buildCountEqualsEncoder(parser); + public static CountEncoder newCountEqualsEncoder() { + return CountEncoder.buildCountEqualsEncoder(); } - public static CountEncoder newCountLessOrEqualEncoder(ProgramParser parser, boolean useSortingGridEncoding) { - return CountEncoder.buildCountLessOrEqualEncoder(parser, useSortingGridEncoding); + public static CountEncoder newCountLessOrEqualEncoder(boolean useSortingGridEncoding) { + return CountEncoder.buildCountLessOrEqualEncoder(useSortingGridEncoding); } - public static SumEncoder newSumEqualsEncoder(ProgramParser parser, boolean supportNegativeSumElements) { - return SumEncoder.buildSumEqualsEncoder(parser, supportNegativeSumElements); + public static SumEncoder newSumEqualsEncoder(boolean supportNegativeSumElements) { + return SumEncoder.buildSumEqualsEncoder(supportNegativeSumElements); } - public static SumEncoder newSumLessOrEqualEncoder(ProgramParser parser, boolean supportNegativeSumElements) { - return SumEncoder.buildSumLessOrEqualEncoder(parser, supportNegativeSumElements); + public static SumEncoder newSumLessOrEqualEncoder(boolean supportNegativeSumElements) { + return SumEncoder.buildSumLessOrEqualEncoder(supportNegativeSumElements); } - public static MinMaxEncoder newMinEncoder(ProgramParser parser) { - return new MinMaxEncoder(parser, AggregateFunctionSymbol.MIN); + public static MinMaxEncoder newMinEncoder() { + return new MinMaxEncoder(AggregateFunctionSymbol.MIN); } - public static MinMaxEncoder newMaxEncoder(ProgramParser parser) { - return new MinMaxEncoder(parser, AggregateFunctionSymbol.MAX); + public static MinMaxEncoder newMaxEncoder() { + return new MinMaxEncoder(AggregateFunctionSymbol.MAX); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java index be64efabd..44a10a5a3 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java @@ -18,16 +18,16 @@ public final class CountEncoder extends StringtemplateBasedAggregateEncoder { private static final ST CNT_EQ_TEMPLATE = AGGREGATE_ENCODINGS.getInstanceOf("cnt_eq"); private static final ST CNT_LE_COUNTING_GRID_TEMPLATE = AGGREGATE_ENCODINGS.getInstanceOf("cnt_le_counting_grid"); - private CountEncoder(ProgramParser parser, ComparisonOperator acceptedOperator, ST encodingTemplate) { - super(parser, AggregateFunctionSymbol.COUNT, acceptedOperator, encodingTemplate); + private CountEncoder(ComparisonOperator acceptedOperator, ST encodingTemplate) { + super(AggregateFunctionSymbol.COUNT, acceptedOperator, encodingTemplate); } - static CountEncoder buildCountLessOrEqualEncoder(ProgramParser parser, boolean useSortingGrid) { - return new CountEncoder(parser, ComparisonOperators.LE, useSortingGrid ? CNT_LE_SORTING_GRID_TEMPLATE : CNT_LE_COUNTING_GRID_TEMPLATE); + static CountEncoder buildCountLessOrEqualEncoder(boolean useSortingGrid) { + return new CountEncoder(ComparisonOperators.LE, useSortingGrid ? CNT_LE_SORTING_GRID_TEMPLATE : CNT_LE_COUNTING_GRID_TEMPLATE); } - static CountEncoder buildCountEqualsEncoder(ProgramParser parser) { - return new CountEncoder(parser, ComparisonOperators.EQ, CNT_EQ_TEMPLATE); + static CountEncoder buildCountEqualsEncoder() { + return new CountEncoder(ComparisonOperators.EQ, CNT_EQ_TEMPLATE); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 179014554..242fc7719 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -1,13 +1,15 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import org.apache.commons.collections4.SetUtils; import org.stringtemplate.v4.ST; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; @@ -24,7 +26,7 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -72,7 +74,7 @@ public MinMaxEncoder(AggregateFunctionSymbol func) { } @Override - protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) { + protected InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode) { ST encodingTemplate = null; if (this.getAggregateFunctionToEncode() == AggregateFunctionSymbol.MAX) { encodingTemplate = new ST(MAX_LITERAL_ENCODING); @@ -112,7 +114,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) */ NormalHead resultRuleHead = Heads.newNormalHead( Atoms.newBasicAtom(Predicates.getPredicate(resultName, 2), aggregateToEncode.getAggregateArguments(), atom.getLowerBoundTerm())); - List resultRuleBody = new ArrayList<>(); + Set resultRuleBody = new LinkedHashSet<>(); VariableTerm aggregateValue = Terms.newVariable("_AGG_VAL"); ComparisonLiteral aggregateValueComparison = Literals.fromAtom(Atoms.newComparisonAtom(atom.getLowerBoundTerm(), aggregateValue, cmpOp), true); Literal aggregateResult = Atoms.newBasicAtom(Predicates.getPredicate( @@ -121,7 +123,7 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) resultRuleBody.add(aggregateResult); resultRuleBody.add(aggregateValueComparison); resultRuleBody.addAll(aggregateToEncode.getDependencies()); - ASPCore2ProgramBuilder bld = Programs.builder(parser.parse(encodingTemplate.render())); + InputProgramBuilder bld = Programs.builder(parser.parse(encodingTemplate.render())); Rule resultRule = Rules.newRule(resultRuleHead, resultRuleBody); bld.addRule(resultRule); return bld.build(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index 8869c66fe..a7eeb9fab 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -1,13 +1,7 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; -import java.util.Collections; - -import org.apache.commons.collections4.ListUtils; -import org.stringtemplate.v4.ST; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -23,6 +17,12 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationRewriting; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.collections4.ListUtils; +import org.stringtemplate.v4.ST; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashSet; /** * Abstract base class for aggregate encoders making use of stringtemplates in their rewriting workflow. @@ -53,7 +53,7 @@ protected StringtemplateBasedAggregateEncoder(AggregateFunctionSymbol aggregateF } @Override - protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) { + protected InputProgram encodeAggregateResult(AggregateInfo aggregateToEncode) { String aggregateId = aggregateToEncode.getId(); /* @@ -81,10 +81,10 @@ protected ASPCore2Program encodeAggregateResult(AggregateInfo aggregateToEncode) String coreEncodingAsp = coreEncodingTemplate.render(); // Create the basic program - ASPCore2Program coreEncoding = new EnumerationRewriting().apply(parser.parse(coreEncodingAsp)); + InputProgram coreEncoding = new EnumerationRewriting().apply(parser.parse(coreEncodingAsp)); // Add the programatically created bound rule and return - return Programs.newASPCore2Program(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), + return Programs.newInputProgram(ListUtils.union(coreEncoding.getRules(), Collections.singletonList(boundRule)), coreEncoding.getFacts(), Programs.newInlineDirectives()); } @@ -95,13 +95,13 @@ private String getBoundPredicateName(String aggregateId) { private Rule buildZeroBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), Terms.newConstant(0)); - return Rules.newRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), new LinkedHashSet<>(aggregateToEncode.getDependencies())); } private Rule buildBoundRule(AggregateInfo aggregateToEncode) { BasicAtom bound = Atoms.newBasicAtom(Predicates.getPredicate(getBoundPredicateName(aggregateToEncode.getId()), 2), aggregateToEncode.getAggregateArguments(), aggregateToEncode.getLiteral().getAtom().getLowerBoundTerm()); - return Rules.newRule(Heads.newNormalHead(bound), new ArrayList<>(aggregateToEncode.getDependencies())); + return Rules.newRule(Heads.newNormalHead(bound), new LinkedHashSet<>(aggregateToEncode.getDependencies())); } } diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java index 1fee5aab3..0dc4a0358 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java @@ -33,16 +33,16 @@ public final class SumEncoder extends StringtemplateBasedAggregateEncoder { private static final ST NON_NEG_ELEMENTS_SUM_LE_TEMPLATE = AGGREGATE_ENCODINGS.getInstanceOf("sum_le_no_negative_elements"); private static final ST NON_NEG_ELEMENTS_SUM_EQ_TEMPLATE = AGGREGATE_ENCODINGS.getInstanceOf("sum_eq_no_negative_elements"); - private SumEncoder(ProgramParser parser, ComparisonOperator acceptedOperator, ST encodingTemplate) { - super(parser, AggregateFunctionSymbol.SUM, acceptedOperator, encodingTemplate); + private SumEncoder(ComparisonOperator acceptedOperator, ST encodingTemplate) { + super(AggregateFunctionSymbol.SUM, acceptedOperator, encodingTemplate); } - static SumEncoder buildSumLessOrEqualEncoder(ProgramParser parser, boolean supportNegativeIntegers) { - return new SumEncoder(parser, ComparisonOperators.LE, supportNegativeIntegers ? SUM_LE_TEMPLATE : NON_NEG_ELEMENTS_SUM_LE_TEMPLATE); + static SumEncoder buildSumLessOrEqualEncoder(boolean supportNegativeIntegers) { + return new SumEncoder(ComparisonOperators.LE, supportNegativeIntegers ? SUM_LE_TEMPLATE : NON_NEG_ELEMENTS_SUM_LE_TEMPLATE); } - static SumEncoder buildSumEqualsEncoder(ProgramParser parser, boolean supportNegativeIntegers) { - return new SumEncoder(parser, ComparisonOperators.EQ, supportNegativeIntegers ? SUM_EQ_TEMPLATE : NON_NEG_ELEMENTS_SUM_EQ_TEMPLATE); + static SumEncoder buildSumEqualsEncoder(boolean supportNegativeIntegers) { + return new SumEncoder(ComparisonOperators.EQ, supportNegativeIntegers ? SUM_EQ_TEMPLATE : NON_NEG_ELEMENTS_SUM_EQ_TEMPLATE); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java index baf96bfb5..a3f81eefa 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRules.java @@ -4,7 +4,9 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; public final class CompiledRules { @@ -13,7 +15,7 @@ private CompiledRules() { } public static CompiledRule newCompiledRule(NormalHead head, Set body) { - return new CompiledRuleImpl(head, body); + return new InternalRule(head, body); } public static CompiledRule newCompiledRule(NormalHead head, Literal... body) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java index ed7e4b1fb..47e037d87 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/solver/TrailAssignment.java @@ -45,7 +45,6 @@ import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomOf; import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.atomToLiteral; import static at.ac.tuwien.kr.alpha.core.programs.atoms.Literals.isPositive; -import static at.ac.tuwien.kr.alpha.core.solver.Atoms.isAtom; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.FALSE; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.MBT; import static at.ac.tuwien.kr.alpha.core.solver.ThriceTruth.TRUE; @@ -338,7 +337,7 @@ private boolean assignmentsConsistent(ThriceTruth oldTruth, ThriceTruth value) { } private ConflictCause assignWithTrail(int atom, ThriceTruth value, Antecedent impliedBy) { - if (!isAtom(atom)) { + if (!AtomStore.isAtom(atom)) { throw new IllegalArgumentException("not an atom"); } if (value == null) { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java index 349249c17..2f2b41740 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/RuleTest.java @@ -7,7 +7,7 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; @@ -35,11 +35,11 @@ public void renameVariables() { @Test public void testRulesEqual() { - ASPCore2Program p1 = parser.parse("p(X, Y) :- bla(X), blub(Y), foo(X, Y), not bar(X)."); + InputProgram p1 = parser.parse("p(X, Y) :- bla(X), blub(Y), foo(X, Y), not bar(X)."); Rule r1 = p1.getRules().get(0); - ASPCore2Program p2 = parser.parse("p(X, Y) :- bla(X), blub(Y), foo(X, Y), not bar(X)."); + InputProgram p2 = parser.parse("p(X, Y) :- bla(X), blub(Y), foo(X, Y), not bar(X)."); Rule r2 = p2.getRules().get(0); - ASPCore2Program p3 = parser.parse("p(X, Y) :- bla(X), blub(X), foo(X, X), not bar(X)."); + InputProgram p3 = parser.parse("p(X, Y) :- bla(X), blub(X), foo(X, X), not bar(X)."); Rule r3 = p3.getRules().get(0); assertTrue(r1.equals(r2)); assertTrue(r2.equals(r1)); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java index 1f1ca1d9b..cdee89727 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java @@ -43,7 +43,7 @@ import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; @@ -100,7 +100,7 @@ public void resetRuleIdGenerator() { */ @Test public void groundRuleAlreadyGround() { - ASPCore2Program program = PROGRAM_PARSER.parse("a :- not b. " + InputProgram program = PROGRAM_PARSER.parse("a :- not b. " + "b :- not a. " + "c :- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); @@ -121,7 +121,7 @@ public void groundRuleAlreadyGround() { */ @Test public void groundRuleWithLongerBodyAlreadyGround() { - ASPCore2Program program = PROGRAM_PARSER.parse("a :- not b. " + InputProgram program = PROGRAM_PARSER.parse("a :- not b. " + "b :- not a. " + "c :- b. " + "d :- b, c. "); @@ -147,7 +147,7 @@ public void groundRuleWithLongerBodyAlreadyGround() { */ @Test public void groundConstraintAlreadyGround() { - ASPCore2Program program = PROGRAM_PARSER.parse("a :- not b. " + InputProgram program = PROGRAM_PARSER.parse("a :- not b. " + "b :- not a. " + ":- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); @@ -237,7 +237,7 @@ private void testDeadEnd(String predicateNameOfStartingLiteral, RuleGroundingOrd @Test public void testGroundingOfRuleSwitchedOffByFalsePositiveBody() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X). " + "b(X) :- something(X). "); testIfGrounderGroundsRule(program, 0, litAX, 1, ThriceTruth.FALSE, false); @@ -245,7 +245,7 @@ public void testGroundingOfRuleSwitchedOffByFalsePositiveBody() { @Test public void testGroundingOfRuleNotSwitchedOffByTruePositiveBody() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X). " + "b(X) :- something(X). "); testIfGrounderGroundsRule(program, 0, litAX, 1, ThriceTruth.TRUE, true); @@ -254,7 +254,7 @@ public void testGroundingOfRuleNotSwitchedOffByTruePositiveBody() { @Test @Disabled("Currently, rule grounding is not switched off by a true negative body atom") public void testGroundingOfRuleSwitchedOffByTrueNegativeBody() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), not b(X). " + "b(X) :- something(X). "); testIfGrounderGroundsRule(program, 0, litAX, 1, ThriceTruth.TRUE, false); @@ -262,7 +262,7 @@ public void testGroundingOfRuleSwitchedOffByTrueNegativeBody() { @Test public void testGroundingOfRuleNotSwitchedOffByFalseNegativeBody() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), not b(X). " + "b(X) :- something(X). "); @@ -276,7 +276,7 @@ public void testGroundingOfRuleNotSwitchedOffByFalseNegativeBody() { * {@code bTruth}. * It is asserted that ground instantiations are produced if and only if {@code expectNoGoods} is true. */ - private void testIfGrounderGroundsRule(ASPCore2Program program, int ruleID, Literal startingLiteral, int startingInstance, ThriceTruth bTruth, + private void testIfGrounderGroundsRule(InputProgram program, int ruleID, Literal startingLiteral, int startingInstance, ThriceTruth bTruth, boolean expectNoGoods) { CompiledProgram internalPrg = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(program)); AtomStore atomStore = new AtomStoreImpl(); @@ -299,7 +299,7 @@ private void testIfGrounderGroundsRule(ASPCore2Program program, int ruleID, Lite @Test public void testPermissiveGrounderHeuristicTolerance_0_reject() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 0, false, Arrays.asList(1)); @@ -307,7 +307,7 @@ public void testPermissiveGrounderHeuristicTolerance_0_reject() { @Test public void testPermissiveGrounderHeuristicTolerance_1_accept() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 1, true, Arrays.asList(1)); @@ -315,7 +315,7 @@ public void testPermissiveGrounderHeuristicTolerance_1_accept() { @Test public void testPermissiveGrounderHeuristicTolerance_1_reject() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X), b(X+1). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 1, false, Arrays.asList(2)); @@ -323,7 +323,7 @@ public void testPermissiveGrounderHeuristicTolerance_1_reject() { @Test public void testPermissiveGrounderHeuristicTolerance_2_accept() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X), b(X+1). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 2, true, Arrays.asList(2)); @@ -331,7 +331,7 @@ public void testPermissiveGrounderHeuristicTolerance_2_accept() { @Test public void testPermissiveGrounderHeuristicTolerance_1_accept_two_substitutions() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X,Y). " + "b(X,Y) :- something(X,Y)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 1, new ThriceTruth[] {ThriceTruth.TRUE, ThriceTruth.TRUE }, 2, true, @@ -340,7 +340,7 @@ public void testPermissiveGrounderHeuristicTolerance_1_accept_two_substitutions( @Test public void testPermissiveGrounderHeuristicTolerance_1_accept_accept_two_substitutions_with_different_remaining_tolerances() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(1), b(X,Y). " + "b(X,Y) :- something(X,Y)."); testPermissiveGrounderHeuristicTolerance(program, 0, litA1, 1, 1, new ThriceTruth[] {null, null }, 2, true, Arrays.asList(1, 1)); @@ -348,7 +348,7 @@ public void testPermissiveGrounderHeuristicTolerance_1_accept_accept_two_substit @Test public void testPermissiveGrounderHeuristicTolerance_2_reject() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). " + "c(X) :- a(X), b(X), b(X+1), b(X+2). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 2, false, Arrays.asList(3)); @@ -356,13 +356,13 @@ public void testPermissiveGrounderHeuristicTolerance_2_reject() { @Test public void testPermissiveGrounderHeuristicTolerance_2_accept_multiple_facts_of_same_variable() { - ASPCore2Program program = PROGRAM_PARSER.parse("a(1). b(1). " + InputProgram program = PROGRAM_PARSER.parse("a(1). b(1). " + "c(X) :- a(X), b(X), b(X+1), b(X+2). " + "b(X) :- something(X)."); testPermissiveGrounderHeuristicTolerance(program, 0, litAX, 1, 2, true, Arrays.asList(2)); } - private void testPermissiveGrounderHeuristicTolerance(ASPCore2Program program, int ruleID, Literal startingLiteral, int startingInstance, int tolerance, + private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int ruleID, Literal startingLiteral, int startingInstance, int tolerance, boolean expectNoGoods, List expectedNumbersOfUnassignedPositiveBodyAtoms) { testPermissiveGrounderHeuristicTolerance(program, ruleID, startingLiteral, startingInstance, tolerance, new ThriceTruth[] {}, 1, expectNoGoods, expectedNumbersOfUnassignedPositiveBodyAtoms); @@ -386,7 +386,7 @@ private void testPermissiveGrounderHeuristicTolerance(ASPCore2Program program, i * If ground instantiations are produced, it is also asserted that the numbers of unassigned positive body atoms * determined by {@code getGroundInstantiations} match those given in {@code expectedNumbersOfUnassignedPositiveBodyAtoms}. */ - private void testPermissiveGrounderHeuristicTolerance(ASPCore2Program program, int ruleID, Literal startingLiteral, int startingInstance, int tolerance, + private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int ruleID, Literal startingLiteral, int startingInstance, int tolerance, ThriceTruth[] truthsOfB, int arityOfB, boolean expectNoGoods, List expectedNumbersOfUnassignedPositiveBodyAtoms) { CompiledProgram internalPrg = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(program)); AtomStore atomStore = new AtomStoreImpl(); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java index 501978758..ef42a9eb7 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java @@ -33,7 +33,7 @@ import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; @@ -71,7 +71,7 @@ public class NoGoodGeneratorTest { */ @Test public void collectNeg_ContainsOnlyPositiveLiterals() { - ASPCore2Program input = PARSER.parse("p(a,b). " + InputProgram input = PARSER.parse("p(a,b). " + "q(a,b) :- not nq(a,b). " + "nq(a,b) :- not q(a,b)."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(input); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java index efae731d9..a59a958d3 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/UnifierTest.java @@ -32,7 +32,7 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -78,7 +78,7 @@ public void mergeUnifierIntoLeft() { private BasicAtom parseAtom(String atom) { ProgramParser programParser = new ProgramParserImpl(); - ASPCore2Program program = programParser.parse(atom + "."); + InputProgram program = programParser.parse(atom + "."); return (BasicAtom) program.getFacts().get(0); } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java index fd40c3db6..7b96f4f92 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java @@ -1,11 +1,11 @@ package at.ac.tuwien.kr.alpha.core.parser; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; public class AspCore2ParserTest extends ParserTest { protected AspCore2ParserTest() { - super(new ASPCore2ProgramParser()); + super(new InputProgramParser()); } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java index 3c4da3aaa..3557a6fa0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/ParserTest.java @@ -46,7 +46,7 @@ import org.antlr.v4.runtime.CharStreams; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -91,7 +91,7 @@ public class ParserTest { @Test public void parseFact() { - ASPCore2Program parsedProgram = parser.parse("p(a,b)."); + InputProgram parsedProgram = parser.parse("p(a,b)."); assertEquals(1, parsedProgram.getFacts().size(), "Program contains one fact."); assertEquals("p", parsedProgram.getFacts().get(0).getPredicate().getName(), "Predicate name of fact is p."); @@ -102,7 +102,7 @@ public void parseFact() { @Test public void parseFactWithFunctionTerms() { - ASPCore2Program parsedProgram = parser.parse("p(f(a),g(h(Y)))."); + InputProgram parsedProgram = parser.parse("p(f(a),g(h(Y)))."); assertEquals(1, parsedProgram.getFacts().size(), "Program contains one fact."); assertEquals("p", parsedProgram.getFacts().get(0).getPredicate().getName(), "Predicate name of fact is p."); @@ -113,7 +113,7 @@ public void parseFactWithFunctionTerms() { @Test public void parseSmallProgram() { - ASPCore2Program parsedProgram = parser.parse( + InputProgram parsedProgram = parser.parse( "a :- b, not d." + System.lineSeparator() + "c(X) :- p(X,a,_), q(Xaa,xaa)." + System.lineSeparator() + ":- f(Y)."); @@ -130,7 +130,7 @@ public void parseBadSyntax() { @Test public void parseBuiltinAtom() { - ASPCore2Program parsedProgram = parser.parse("a :- p(X), X != Y, q(Y)."); + InputProgram parsedProgram = parser.parse("a :- p(X), X != Y, q(Y)."); assertEquals(1, parsedProgram.getRules().size()); assertEquals(3, parsedProgram.getRules().get(0).getBody().size()); } @@ -145,7 +145,7 @@ public void parseProgramWithDisjunctionInHead() { @Test public void parseInterval() { - ASPCore2Program parsedProgram = parser.parse("fact(2..5). p(X) :- q(a, 3 .. X)."); + InputProgram parsedProgram = parser.parse("fact(2..5). p(X) :- q(a, 3 .. X)."); IntervalTerm factInterval = (IntervalTerm) parsedProgram.getFacts().get(0).getTerms().get(0); assertTrue(factInterval.equals(Terms.newIntervalTerm(Terms.newConstant(2), Terms.newConstant(5)))); IntervalTerm bodyInterval = (IntervalTerm) parsedProgram.getRules().get(0).getBody().stream().findFirst().get().getTerms().get(1); @@ -154,7 +154,7 @@ public void parseInterval() { @Test public void parseChoiceRule() { - ASPCore2Program parsedProgram = parser.parse("dom(1). dom(2). { a ; b } :- dom(X)."); + InputProgram parsedProgram = parser.parse("dom(1). dom(2). { a ; b } :- dom(X)."); ChoiceHead choiceHead = (ChoiceHead) parsedProgram.getRules().get(0).getHead(); assertEquals(2, choiceHead.getChoiceElements().size()); assertTrue(choiceHead.getChoiceElements().get(0).getChoiceAtom().toString().equals("a")); @@ -165,7 +165,7 @@ public void parseChoiceRule() { @Test public void parseChoiceRuleBounded() { - ASPCore2Program parsedProgram = parser.parse("dom(1). dom(2). 1 < { a: p(v,w), not r; b } <= 13 :- dom(X). foo."); + InputProgram parsedProgram = parser.parse("dom(1). dom(2). 1 < { a: p(v,w), not r; b } <= 13 :- dom(X). foo."); ChoiceHead choiceHead = (ChoiceHead) parsedProgram.getRules().get(0).getHead(); assertEquals(2, choiceHead.getChoiceElements().size()); assertTrue(choiceHead.getChoiceElements().get(0).getChoiceAtom().toString().equals("a")); @@ -215,7 +215,7 @@ public void testMissingDotNotIgnored() { @Test public void parseEnumerationDirective() { - ASPCore2Program parsedProgram = parser.parse("p(a,1)." + + InputProgram parsedProgram = parser.parse("p(a,1)." + "# enumeration_predicate_is mune." + "r(X) :- p(X), mune(X)." + "p(b,2)."); @@ -225,7 +225,7 @@ public void parseEnumerationDirective() { @Test public void cardinalityAggregate() { - ASPCore2Program parsedProgram = parser.parse("num(K) :- K <= #count {X,Y,Z : p(X,Y,Z) }, dom(K)."); + InputProgram parsedProgram = parser.parse("num(K) :- K <= #count {X,Y,Z : p(X,Y,Z) }, dom(K)."); Optional optionalBodyElement = parsedProgram.getRules().get(0).getBody().stream().filter((lit) -> lit instanceof AggregateLiteral).findFirst(); assertTrue(optionalBodyElement.isPresent()); Literal bodyElement = optionalBodyElement.get(); @@ -244,7 +244,7 @@ public void cardinalityAggregate() { @Test public void stringWithEscapedQuotes() throws IOException { CharStream stream = CharStreams.fromStream(ParserTest.class.getResourceAsStream("/escaped_quotes.asp")); - ASPCore2Program prog = parser.parse(stream); + InputProgram prog = parser.parse(stream); assertEquals(1, prog.getFacts().size()); Atom stringAtom = prog.getFacts().get(0); String stringWithQuotes = stringAtom.getTerms().get(0).toString(); @@ -253,7 +253,7 @@ public void stringWithEscapedQuotes() throws IOException { @Test public void unitTestExpectUnsat() { - ASPCore2Program prog = parser.parse(UNIT_TEST_EXPECT_UNSAT); + InputProgram prog = parser.parse(UNIT_TEST_EXPECT_UNSAT); assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); assertEquals("expected_unsat", tc.getName()); @@ -263,7 +263,7 @@ public void unitTestExpectUnsat() { @Test public void unitTestBasicTest() { - ASPCore2Program prog = parser.parse(UNIT_TEST_BASIC_TEST); + InputProgram prog = parser.parse(UNIT_TEST_BASIC_TEST); assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); assertEquals("ensure_a", tc.getName()); @@ -274,7 +274,7 @@ public void unitTestBasicTest() { @Test public void unitTestMultipleAsserts() { - ASPCore2Program prog = parser.parse(UNIT_TEST_MORE_ASSERTIONS); + InputProgram prog = parser.parse(UNIT_TEST_MORE_ASSERTIONS); assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); assertEquals("ensure_a", tc.getName()); @@ -286,7 +286,7 @@ public void unitTestMultipleAsserts() { @Test public void unitTestMoreTCs() { - ASPCore2Program prog = parser.parse(UNIT_TEST_MORE_TCS); + InputProgram prog = parser.parse(UNIT_TEST_MORE_TCS); assertEquals(2, prog.getTestCases().size()); TestCase tc1 = prog.getTestCases().get(0); assertEquals("ensure_a", tc1.getName()); @@ -296,7 +296,7 @@ public void unitTestMoreTCs() { @Test public void unitTestKeywordsAsIds() { - ASPCore2Program prog = parser.parse(UNIT_TEST_KEYWORDS_AS_IDS); + InputProgram prog = parser.parse(UNIT_TEST_KEYWORDS_AS_IDS); assertEquals(1, prog.getTestCases().size()); TestCase tc = prog.getTestCases().get(0); assertEquals("test", tc.getName()); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java index 1c0c26b57..d202e579c 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java @@ -15,7 +15,7 @@ import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -58,35 +58,35 @@ public static final Set>> extWithOutput(int in) { @Test public void testIsBasicAtomGround() { - ASPCore2Program p = parser.parse("bla(blubb, foo(bar))."); + InputProgram p = parser.parse("bla(blubb, foo(bar))."); Atom a = p.getFacts().get(0); assertBasicAtomGround(a, true); - ASPCore2Program p1 = parser.parse("foo(1, 2, 3, \"bar\")."); + InputProgram p1 = parser.parse("foo(1, 2, 3, \"bar\")."); Atom a1 = p1.getFacts().get(0); assertBasicAtomGround(a1, true); - ASPCore2Program p2 = parser.parse("foo(BAR)."); + InputProgram p2 = parser.parse("foo(BAR)."); Atom a2 = p2.getFacts().get(0); assertBasicAtomGround(a2, false); - ASPCore2Program p3 = parser.parse("foo(b, a, r(\"bla\", BLUBB))."); + InputProgram p3 = parser.parse("foo(b, a, r(\"bla\", BLUBB))."); Atom a3 = p3.getFacts().get(0); assertBasicAtomGround(a3, false); } @Test public void testAreBasicAtomsEqual() { - ASPCore2Program p1 = parser.parse("bla(blubb, foo(bar)). bla(blubb, foo(bar))."); + InputProgram p1 = parser.parse("bla(blubb, foo(bar)). bla(blubb, foo(bar))."); Atom a1 = p1.getFacts().get(0); Atom a2 = p1.getFacts().get(1); assertEquals(a1, a2); - ASPCore2Program p2 = parser.parse("foo(1, 2, 3, \"bar\"). foo(1, 2, 3, \"bar\")."); + InputProgram p2 = parser.parse("foo(1, 2, 3, \"bar\"). foo(1, 2, 3, \"bar\")."); Atom a3 = p2.getFacts().get(0); Atom a4 = p2.getFacts().get(1); assertEquals(a3, a4); - ASPCore2Program p3 = parser.parse("foo(BAR). foo(BAR)."); + InputProgram p3 = parser.parse("foo(BAR). foo(BAR)."); Atom a5 = p3.getFacts().get(0); Atom a6 = p3.getFacts().get(1); assertEquals(a5, a6); - ASPCore2Program p4 = parser.parse("foo(b, a, r(\"bla\", BLUBB)). foo(b, a, r(\"bla\", BLUBB))."); + InputProgram p4 = parser.parse("foo(b, a, r(\"bla\", BLUBB)). foo(b, a, r(\"bla\", BLUBB))."); Atom a7 = p4.getFacts().get(0); Atom a8 = p4.getFacts().get(1); assertEquals(a7, a8); @@ -101,13 +101,13 @@ public void testAreBasicAtomsEqual() { @Test public void testIsExternalAtomGround() { - ASPCore2Program p1 = parser.parse("a :- &isFoo[1].", externals); + InputProgram p1 = parser.parse("a :- &isFoo[1].", externals); Atom ext1 = p1.getRules().get(0).getBody().stream().findFirst().get().getAtom(); assertExternalAtomGround(ext1, true); - ASPCore2Program p2 = parser.parse("a :- &isFoo[bar(1)].", externals); + InputProgram p2 = parser.parse("a :- &isFoo[bar(1)].", externals); Atom ext2 = p2.getRules().get(0).getBody().stream().findFirst().get().getAtom(); assertExternalAtomGround(ext2, true); - ASPCore2Program p3 = parser.parse("a :- &isFoo[BLA].", externals); + InputProgram p3 = parser.parse("a :- &isFoo[BLA].", externals); Atom ext3 = p3.getRules().get(0).getBody().stream().findFirst().get().getAtom(); assertExternalAtomGround(ext3, false); } @@ -115,9 +115,9 @@ public void testIsExternalAtomGround() { @Test @SuppressWarnings("unlikely-arg-type") public void testAreExternalAtomsEqual() { - ASPCore2Program p1 = parser.parse("a :- &isFoo[1].", externals); + InputProgram p1 = parser.parse("a :- &isFoo[1].", externals); Atom ext1 = p1.getRules().get(0).getBody().stream().findFirst().get().getAtom(); - ASPCore2Program p2 = parser.parse("a :- &isFoo[1].", externals); + InputProgram p2 = parser.parse("a :- &isFoo[1].", externals); Atom ext2 = p2.getRules().get(0).getBody().stream().findFirst().get().getAtom(); assertEquals(ext1, ext2); assertEquals(ext2, ext1); @@ -129,7 +129,7 @@ public void testAreExternalAtomsEqual() { @Test public void testExternalHasOutput() { - ASPCore2Program p = parser.parse("a:- &extWithOutput[1](OUT).", externals); + InputProgram p = parser.parse("a:- &extWithOutput[1](OUT).", externals); Atom ext = p.getRules().get(0).getBody().stream().findFirst().get().getAtom(); assertExternalAtomGround(ext, false); assertTrue(((ExternalAtom) ext).hasOutput()); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index d7ff68a37..79ae8be23 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -12,7 +12,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; @@ -44,11 +44,11 @@ private static String readTestResource(String resource) throws IOException { } private , O extends Program> void genericTransformationTest(ProgramTransformation transform, - Function prepareFunc, String resourceSet) { + Function prepareFunc, String resourceSet) { try { String inputCode = ProgramTransformationTest.readTestResource(resourceSet + ".in"); String expectedResult = ProgramTransformationTest.readTestResource(resourceSet + ".out"); - ASPCore2Program inputProg = PARSER.parse(inputCode, Externals.scan(ProgramTransformationTest.class)); + InputProgram inputProg = PARSER.parse(inputCode, Externals.scan(ProgramTransformationTest.class)); I transformInput = prepareFunc.apply(inputProg); String beforeTransformProg = transformInput.toString(); O transformedProg = transform.apply(transformInput); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java index 8715675b0..383cf8ac0 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java @@ -18,7 +18,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.Predicates; @@ -105,7 +105,7 @@ public static List params() { public void runTest(String aspString, Consumer programVerifier, Consumer> resultVerifier) { // Parse and pre-evaulate program ProgramParser parser = new ProgramParserImpl(); - ASPCore2Program prog = parser.parse(aspString); + InputProgram prog = parser.parse(aspString); AnalyzedProgram analyzed = AnalyzedProgram .analyzeNormalProgram(new NormalizeProgramTransformation(SystemConfig.DEFAULT_AGGREGATE_REWRITING_CONFIG).apply(prog)); CompiledProgram evaluated = new StratifiedEvaluation().apply(analyzed); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java index fe0bd40b0..23eff4511 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/ChoiceManagerTests.java @@ -34,7 +34,7 @@ import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; @@ -54,7 +54,7 @@ public class ChoiceManagerTests { @BeforeEach public void setUp() { String testProgram = "h :- b1, b2, not b3, not b4."; - ASPCore2Program parsedProgram = new ProgramParserImpl().parse(testProgram); + InputProgram parsedProgram = new ProgramParserImpl().parse(testProgram); CompiledProgram internalProgram = InternalProgram.fromNormalProgram(new NormalizeProgramTransformation(SystemConfig.DEFAULT_AGGREGATE_REWRITING_CONFIG).apply(parsedProgram)); atomStore = new AtomStoreImpl(); grounder = new NaiveGrounder(internalProgram, atomStore, true); diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java index 7de3ef84d..8c45bf662 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java @@ -1,18 +1,19 @@ package at.ac.tuwien.kr.alpha.test; -import static java.util.Collections.emptySet; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import at.ac.tuwien.kr.alpha.api.AnswerSet; +import at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser; +import at.ac.tuwien.kr.alpha.api.programs.Program; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.Set; import java.util.StringJoiner; -import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.programs.Program; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import static java.util.Collections.emptySet; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AlphaAssertions { diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index b3c014c13..53d5eb323 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -1,5 +1,6 @@ package at.ac.tuwien.kr.alpha.api.impl; +import java.util.Collections; import java.util.function.Supplier; import at.ac.tuwien.kr.alpha.api.Alpha; @@ -9,43 +10,26 @@ import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; +import at.ac.tuwien.kr.alpha.commons.programs.reification.Reifier; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.actions.ActionExecutionServiceImpl; import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ChoiceHeadNormalizer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.EnumerationTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.IntervalTermTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramNormalizer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformer; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; -import at.ac.tuwien.kr.alpha.core.programs.transformation.VariableEqualityTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateTransformer; -import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders.AggregateEncoders; import at.ac.tuwien.kr.alpha.core.solver.SolverConfig; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; import at.ac.tuwien.kr.alpha.core.solver.heuristics.HeuristicsConfiguration; public class AlphaFactory { - protected ProgramTransformer newProgramNormalizer(ProgramParser parser, - AggregateRewritingConfig aggregateCfg) { - return new ProgramNormalizer( - new VariableEqualityTransformer(), - new ChoiceHeadNormalizer(), - new AggregateTransformer( - AggregateEncoders.newCountEqualsEncoder(parser), - AggregateEncoders.newCountLessOrEqualEncoder(parser, aggregateCfg.isUseSortingGridEncoding()), - AggregateEncoders.newSumEqualsEncoder(parser, aggregateCfg.isSupportNegativeValuesInSums()), - AggregateEncoders.newSumLessOrEqualEncoder(parser, aggregateCfg.isSupportNegativeValuesInSums()), - AggregateEncoders.newMinEncoder(parser), - AggregateEncoders.newMaxEncoder(parser)), - new EnumerationTransformer(), - new IntervalTermTransformer(), - new ArithmeticTermTransformer()); + protected ProgramTransformation newProgramNormalizer(AggregateRewritingConfig aggregateCfg) { + return new NormalizeProgramTransformation(aggregateCfg); } protected Supplier newStratifiedEvaluationFactory(ActionImplementationProvider actionImplementationProvider, @@ -83,15 +67,8 @@ protected ActionImplementationProvider newActionImplementationProvider() { public Alpha newAlpha(SystemConfig cfg) { ActionImplementationProvider actionImplementationProvider = newActionImplementationProvider(); - ProgramParser parser; - if (cfg.isAcceptEvologPrograms()) { - parser = new EvologProgramParser(actionImplementationProvider); // TODO need to give stdin/stdout definitions to parser (pass in implementation - // provider) - } else { - parser = new ASPCore2ProgramParser(); - } - ProgramTransformer programNormalizer = newProgramNormalizer(parser, - cfg.getAggregateRewritingConfig()); + ProgramParser parser = new ProgramParserImpl(actionImplementationProvider, Collections.emptyMap()); + ProgramTransformation programNormalizer = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()); // Stratified evaluation factory - since every instance of stratified evaluation is only good for one program, we need a factory. Supplier stratifiedEvaluationFactory = newStratifiedEvaluationFactory(actionImplementationProvider, cfg.isDebugInternalChecks()); @@ -103,7 +80,10 @@ public Alpha newAlpha(SystemConfig cfg) { SolverFactory solverFactory = newSolverFactory(cfg); // Now that all dependencies are taken care of, build new Alpha instance. - return new AlphaImpl(parser, programNormalizer, stratifiedEvaluationFactory, grounderFactory, solverFactory, cfg.isSortAnswerSets()); + return new AlphaImpl(parser, programNormalizer, stratifiedEvaluationFactory, grounderFactory, solverFactory, new Reifier(() -> { + IdGenerator idGen = new IntIdGenerator(0); + return () -> Terms.newConstant(idGen.getNextId()); + }), cfg.isSortAnswerSets()); } // Create Alpha instance with default config. diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 8534b91b4..78631d11b 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -32,10 +32,8 @@ import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; import at.ac.tuwien.kr.alpha.api.config.InputConfig; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; @@ -44,21 +42,17 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.reification.Reifier; -import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.util.IdGenerator; -import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ProgramTransformation; import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; import com.google.common.annotations.VisibleForTesting; @@ -76,6 +70,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -83,29 +78,37 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); - private final SystemConfig config; // Config is initialized with default values. - private final ProgramParser parser = new ProgramParserImpl(); - - private final TestRunner testRunner; - private final Reifier reifier = new Reifier(() -> { - IdGenerator idGen = new IntIdGenerator(0); - return () -> Terms.newConstant(idGen.getNextId()); - }); + private final ProgramParser parser; + private final ProgramTransformation programNormalization; - public AlphaImpl(SystemConfig cfg) { - this.config = cfg; + private final Supplier stratifiedEvaluationFactory; + private final GrounderFactory grounderFactory; + private final SolverFactory solverFactory; + private final TestRunner testRunner; + private final Reifier reifier; + private final boolean sortAnswerSets; + + AlphaImpl(ProgramParser parser, ProgramTransformation programNormalization, + Supplier stratifiedEvaluationFactory, + GrounderFactory grounderFactory, + SolverFactory solverFactory, + Reifier reifier, + boolean sortAnswerSets) { + this.parser = parser; + this.programNormalization = programNormalization; + this.stratifiedEvaluationFactory = stratifiedEvaluationFactory; + this.grounderFactory = grounderFactory; + this.solverFactory = solverFactory; + this.reifier = reifier; this.testRunner = new TestRunner(this); - } - - public AlphaImpl() { - this(new SystemConfig()); + this.sortAnswerSets = sortAnswerSets; } @Override - public ASPCore2Program readProgram(InputConfig cfg) throws IOException { - ASPCore2ProgramBuilder prgBuilder = Programs.builder(); - ASPCore2Program tmpProg; + public InputProgram readProgram(InputConfig cfg) throws IOException { + InputProgramBuilder prgBuilder = Programs.builder(); + InputProgram tmpProg; if (!cfg.getFiles().isEmpty()) { tmpProg = readProgramFiles(cfg.isLiterate(), cfg.getPredicateMethods(), cfg.getFiles()); prgBuilder.accumulate(tmpProg); @@ -118,14 +121,14 @@ public ASPCore2Program readProgram(InputConfig cfg) throws IOException { } @Override - public ASPCore2Program readProgramFiles(boolean literate, Map externals, List paths) throws IOException { + public InputProgram readProgramFiles(boolean literate, Map externals, List paths) throws IOException { return readProgramFiles(literate, externals, paths.stream().map(Paths::get).collect(Collectors.toList()).toArray(new Path[] {})); } @Override - public ASPCore2Program readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException { - ASPCore2ProgramBuilder prgBuilder = Programs.builder(); - ASPCore2Program tmpProg; + public InputProgram readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException { + InputProgramBuilder prgBuilder = Programs.builder(); + InputProgram tmpProg; for (Path path : paths) { InputStream stream; if (!literate) { @@ -140,28 +143,37 @@ public ASPCore2Program readProgramFiles(boolean literate, Map externals) { + public InputProgram readProgramString(String aspString, Map externals) { return parser.parse(aspString, externals); } @Override - public ASPCore2Program readProgramString(String aspString) { + public InputProgram readProgramString(String aspString) { return readProgramString(aspString, Collections.emptyMap()); } @Override - public NormalProgram normalizeProgram(ASPCore2Program program) { - return new NormalizeProgramTransformation(config.getAggregateRewritingConfig()).apply(program); + public InputProgram readProgramStream(InputStream is) throws IOException { + return parser.parse(is); + } + + @Override + public InputProgram readProgramStream(InputStream is, Map externals) throws IOException { + return parser.parse(is, externals); + } + + @Override + public NormalProgram normalizeProgram(InputProgram program) { + return programNormalization.apply(program); } @VisibleForTesting InternalProgram performProgramPreprocessing(NormalProgram program) { + LOGGER.debug("Preprocessing InternalProgram!"); LOGGER.debug("Preprocessing InternalProgram!"); InternalProgram retVal = InternalProgram.fromNormalProgram(program); - if (config.isEvaluateStratifiedPart()) { - AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); - retVal = new StratifiedEvaluation().apply(analyzed); - } + AnalyzedProgram analyzed = new AnalyzedProgram(retVal.getRules(), retVal.getFacts()); + retVal = stratifiedEvaluationFactory.get().apply(analyzed); return retVal; } @@ -170,7 +182,7 @@ InternalProgram performProgramPreprocessing(NormalProgram program) { * program analysis and normalization aren't of interest. */ @Override - public Stream solve(ASPCore2Program program) { + public Stream solve(InputProgram program) { return solve(program, InputConfig.DEFAULT_FILTER); } @@ -179,7 +191,7 @@ public Stream solve(ASPCore2Program program) { * details of the program analysis and normalization aren't of interest. */ @Override - public Stream solve(ASPCore2Program program, java.util.function.Predicate filter) { + public Stream solve(InputProgram program, java.util.function.Predicate filter) { NormalProgram normalized = normalizeProgram(program); return solve(normalized, filter); } @@ -203,12 +215,12 @@ public Stream solve(NormalProgram program, java.util.function.Predica * Solves the given program and filters answer sets based on the passed predicate. * * @param program an {@link InternalProgram} to solve - * @param filter {@link Predicate} filtering {@at.ac.tuwien.kr.alpha.common.Predicate}s in the returned answer sets + * @param filter {@link Predicate} filtering {@link at.ac.tuwien.kr.alpha.api.programs.Predicate}s in the returned answer sets * @return a Stream of answer sets representing stable models of the given program */ private Stream solve(CompiledProgram program, java.util.function.Predicate filter) { Stream retVal = prepareSolverFor(program, filter).stream(); - return config.isSortAnswerSets() ? retVal.sorted() : retVal; + return sortAnswerSets ? retVal.sorted() : retVal; } /** @@ -221,21 +233,13 @@ private Stream solve(CompiledProgram program, java.util.function.Pred * @return a solver (and accompanying grounder) instance pre-loaded with the given program. */ private Solver prepareSolverFor(CompiledProgram program, java.util.function.Predicate filter) { - String grounderName = config.getGrounderName(); - boolean doDebugChecks = config.isDebugInternalChecks(); - - GrounderHeuristicsConfiguration grounderHeuristicConfiguration = GrounderHeuristicsConfiguration - .getInstance(config.getGrounderToleranceConstraints(), config.getGrounderToleranceRules()); - grounderHeuristicConfiguration.setAccumulatorEnabled(config.isGrounderAccumulatorEnabled()); - AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance(grounderName, program, atomStore, filter, grounderHeuristicConfiguration, doDebugChecks); - - return SolverFactory.getInstance(config, atomStore, grounder); + Grounder grounder = grounderFactory.createGrounder(program, atomStore, filter); + return solverFactory.createSolver(grounder, atomStore); } @Override - public DebugSolvingContext prepareDebugSolve(ASPCore2Program program) { + public DebugSolvingContext prepareDebugSolve(InputProgram program) { return prepareDebugSolve(program, InputConfig.DEFAULT_FILTER); } @@ -245,7 +249,7 @@ public DebugSolvingContext prepareDebugSolve(NormalProgram program) { } @Override - public DebugSolvingContext prepareDebugSolve(final ASPCore2Program program, java.util.function.Predicate filter) { + public DebugSolvingContext prepareDebugSolve(final InputProgram program, java.util.function.Predicate filter) { return prepareDebugSolve(normalizeProgram(program), filter); } @@ -255,11 +259,7 @@ public DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.u final ComponentGraph compGraph; final AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(program); final NormalProgram preprocessed; - if (this.config.isEvaluateStratifiedPart()) { - preprocessed = new StratifiedEvaluation().apply(analyzed).toNormalProgram(); - } else { - preprocessed = program; - } + preprocessed = stratifiedEvaluationFactory.get().apply(analyzed).toNormalProgram(); depGraph = analyzed.getDependencyGraph(); compGraph = analyzed.getComponentGraph(); final Solver solver = prepareSolverFor(analyzed, filter); @@ -294,7 +294,7 @@ public ComponentGraph getComponentGraph() { } @Override - public Solver prepareSolverFor(ASPCore2Program program, java.util.function.Predicate filter) { + public Solver prepareSolverFor(InputProgram program, java.util.function.Predicate filter) { return prepareSolverFor(normalizeProgram(program), filter); } @@ -304,12 +304,12 @@ public Solver prepareSolverFor(NormalProgram program, java.util.function.Predica } @Override - public Set reify(ASPCore2Program program) { + public Set reify(InputProgram program) { return reifier.reifyProgram(program); } @Override - public TestResult test(ASPCore2Program program) { + public TestResult test(InputProgram program) { return testRunner.test(program); } diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java index 2ac4bce95..1b408270e 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/TestRunner.java @@ -2,7 +2,7 @@ import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.tests.Assertion; @@ -27,7 +27,7 @@ class TestRunner { this.alpha = alpha; } - TestResult test(ASPCore2Program program) { + TestResult test(InputProgram program) { LOGGER.info("Running unit tests.."); NormalProgram programUnderTest = alpha.normalizeProgram(program); List testCaseResults = program.getTestCases().stream() @@ -103,7 +103,7 @@ private List evaluateAssertion(Set answerSets, Assertion asse } private boolean answerSetSatisfiesAssertion(AnswerSet as, Assertion assertion) { - ASPCore2Program verifierWithInput = Programs.builder(assertion.getVerifier()).addFacts(new ArrayList<>(as.asFacts())).build(); + InputProgram verifierWithInput = Programs.builder(assertion.getVerifier()).addFacts(new ArrayList<>(as.asFacts())).build(); return alpha.solve(verifierWithInput).findAny().isPresent(); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index 1ddfaa7cc..c00df590d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -1,7 +1,19 @@ package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.AnswerSet; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; +import at.ac.tuwien.kr.alpha.core.actions.OutputStreamHandle; +import at.ac.tuwien.kr.alpha.test.util.MockedActionsAlphaFactory; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import java.io.ByteArrayOutputStream; import java.io.OutputStream; @@ -10,21 +22,8 @@ import java.util.Set; import java.util.stream.Collectors; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.util.AnswerSetQueryImpl; -import at.ac.tuwien.kr.alpha.core.actions.ActionImplementationProvider; -import at.ac.tuwien.kr.alpha.core.actions.OutputStreamHandle; -import org.junit.jupiter.api.Test; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import at.ac.tuwien.kr.alpha.api.Alpha; -import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.test.util.MockedActionsAlphaFactory; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * End-to-end tests covering Evolog action support. @@ -72,7 +71,7 @@ public void writeToFile() { * Note: We have to check answer set content here because we have no way of constructing an equal instance for * the outputStreamHandle that is constructed when execution the "fileOutputStream" action. * */ - assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_open_result", 2)) + assertEquals(1, answerSet.query(Atoms.query(Predicates.getPredicate("outfile_open_result", 2)) .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) .withFunctionTerm(1, "success", 1) .withFilter(1, (term) -> { @@ -83,7 +82,7 @@ public void writeToFile() { return streamTerm.getObject() instanceof OutputStreamHandle; }) ).size()); - assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_write_result", 2)) + assertEquals(1, answerSet.query(Atoms.query(Predicates.getPredicate("outfile_write_result", 2)) .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) .withFunctionTerm(1, "success", 1) .withFilter(1, (term) -> { @@ -92,7 +91,7 @@ public void writeToFile() { return funcTerm.getTerms().get(0) instanceof ConstantTerm && ((ConstantTerm) funcTerm.getTerms().get(0)).getObject().equals("ok"); }) ).size()); - assertEquals(1, answerSet.query(AnswerSetQueryImpl.forPredicate(Predicates.getPredicate("outfile_close_result", 2)) + assertEquals(1, answerSet.query(Atoms.query(Predicates.getPredicate("outfile_close_result", 2)) .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) .withFunctionTerm(1, "success", 1) .withFilter(1, (term) -> { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java index 969f26412..a4805b8b3 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java @@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -58,7 +58,7 @@ public class AggregateRewritingContextTest { //@formatter:on private static final AggregateRewritingContext rewritingContextForAspString(String asp) { - ASPCore2Program program = new ProgramParserImpl().parse(asp); + InputProgram program = new ProgramParserImpl().parse(asp); AggregateRewritingContext ctx = new AggregateRewritingContext(); for (Rule rule : program.getRules()) { ctx.registerRule(rule); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java index 288b52fbd..1d11e89d4 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java @@ -12,7 +12,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; @@ -34,7 +34,7 @@ public class AggregateRewritingTest { private static final ProgramParser PARSER = new ProgramParserImpl(); private static final Function> NORMALIZE_AND_SOLVE = (str) -> { SystemConfig cfg = new SystemConfig(); - ASPCore2Program prog = PARSER.parse(str); + InputProgram prog = PARSER.parse(str); NormalProgram normalized = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()).apply(prog); CompiledProgram compiled = InternalProgram.fromNormalProgram(normalized); AtomStore atomStore = new AtomStoreImpl(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java index 5381de504..ee00c7c4b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.core.test.util; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -10,7 +10,7 @@ public class RuleParser { public static Rule parse(String str) { ProgramParser parser = new ProgramParserImpl(); - ASPCore2Program prog = parser.parse(str); + InputProgram prog = parser.parse(str); if (!prog.getFacts().isEmpty()) { throw new IllegalArgumentException("Expected exactly one rule and no facts!"); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index 828f6f922..7b075979e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -31,7 +31,7 @@ import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -97,7 +97,7 @@ private void constructNonGroundRuleAndCheckToString(String textualRule) { } private Rule parseSingleRule(String rule) { - ASPCore2Program program = parser.parse(rule); + InputProgram program = parser.parse(rule); List> rules = program.getRules(); assertEquals(1, rules.size(), "Number of rules"); return rules.get(0); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java index 2cf6b1337..6c6def131 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java @@ -43,7 +43,7 @@ import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -179,7 +179,7 @@ public void testNegatedExternalLiteral() throws Exception { */ @Test public void testPartnerUnitsProblemTopologicalOrder() throws IOException { - ASPCore2Program prg = parser.parse(StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/pup_topological_order.asp")); + InputProgram prg = parser.parse(StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/pup_topological_order.asp")); CompiledProgram evaluated = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normalizer.apply(prg))); assertTrue(evaluated.getRules().isEmpty(), "Not all rules eliminated by stratified evaluation"); assertEquals(57, evaluated.getFacts().size()); @@ -200,7 +200,7 @@ public void testNegatedLiteralInRecursiveRule() throws IOException { + "inc_value(4), inc_value(5), inc_value(6), inc_value(7), " + "inc_value(8)"; //@formatter:on - ASPCore2Program prog = new ProgramParserImpl().parse( + InputProgram prog = new ProgramParserImpl().parse( StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/recursive_w_negated_condition.asp"), new HashMap<>()); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 9a774a18b..0e4086ea9 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -32,7 +32,7 @@ import at.ac.tuwien.kr.alpha.api.config.Heuristic; import at.ac.tuwien.kr.alpha.api.config.InputConfig; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -43,16 +43,16 @@ import at.ac.tuwien.kr.alpha.api.programs.tests.TestResult; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.MethodPredicateInterpretation; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.fixedinterpretations.MethodPredicateInterpretation; -import at.ac.tuwien.kr.alpha.core.externals.AspStandardLibrary; -import at.ac.tuwien.kr.alpha.core.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import org.junit.jupiter.api.Disabled; @@ -147,10 +147,10 @@ public static boolean thinger(Thingy thingy) { @Test public void withExternal() throws Exception { - Alpha alpha = new AlphaImpl(); + Alpha alpha = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("a :- &isOne[1]."); inputCfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); - ASPCore2Program program = alpha.readProgram(inputCfg); + InputProgram program = alpha.readProgram(inputCfg); Set actual = alpha.solve(program).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); assertEquals(expected, actual); @@ -158,11 +158,11 @@ public void withExternal() throws Exception { @Test public void addsFacts() { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); Thingy a = new Thingy(); Thingy b = new Thingy(); List things = asList(a, b); - ASPCore2Program program = Programs.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); + InputProgram program = Programs.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); Set actual = system.solve(program).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build())); assertEquals(expected, actual); @@ -171,7 +171,7 @@ public void addsFacts() { @Test public void withExternalTypeConflict() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); @@ -182,26 +182,26 @@ public void withExternalTypeConflict() { @Test public void smallGraph() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). node(3). a :- &connected[1,2]."); inputCfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); - ASPCore2Program program = system.readProgram(inputCfg); + InputProgram program = system.readProgram(inputCfg); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = AnswerSetsParser.parse("{ a, node(1), node(2), node(3) }"); + Set expected = at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser.parse("{ a, node(1), node(2), node(3) }"); assertEquals(expected, actual); } @Test public void filterOutput() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). outgoing13(X) :- node(X), &getLargeGraphEdges(13,X)."); inputCfg.addPredicateMethod("getLargeGraphEdges", Externals.processPredicate(() -> new HashSet<>(asList(asList(Terms.newConstant(1), Terms.newConstant(2)), asList(Terms.newConstant(2), Terms.newConstant(1)), asList(Terms.newConstant(13), Terms.newConstant(1)))))); - ASPCore2Program program = system.readProgram(inputCfg); + InputProgram program = system.readProgram(inputCfg); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = AnswerSetsParser.parse("{ node(1), node(2), outgoing13(1) }"); + Set expected = at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser.parse("{ node(1), node(2), outgoing13(1) }"); assertEquals(expected, actual); } @@ -210,7 +210,7 @@ public void supplier() throws Exception { Alpha system = new AlphaImpl(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicate(() -> singleton(singletonList(Terms.newConstant(1))))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set expected = AnswerSetsParser.parse("{ node(1), a }"); Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -227,7 +227,7 @@ public void noInput() throws Exception { Alpha system = new AlphaImpl(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicateMethod(this.getClass().getMethod("bestNode"))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set expected = AnswerSetsParser.parse("{ node(1), a }"); Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -237,10 +237,10 @@ public void noInput() throws Exception { @Test public void smallGraphWithWrongType() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); system.solve(prog).collect(Collectors.toSet()); }); @@ -263,10 +263,10 @@ public static Set>> coolNode(int node) { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphNoNeighbors() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("noNeighbors(2) :- not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set expected = AnswerSetsParser.parse("{ noNeighbors(2) }"); Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -275,10 +275,10 @@ public void smallGraphNoNeighbors() throws Exception { @Test public void smallGraphCoolNode() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1..2). in(X) :- node(X), &coolNode[X]."); cfg.addPredicateMethod("coolNode", Externals.processPredicateMethod(this.getClass().getMethod("coolNode", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = AnswerSetsParser.parse("{ in(1), node(1), node(2) }"); @@ -287,10 +287,10 @@ public void smallGraphCoolNode() throws Exception { @Test public void smallGraphSingleNeighbor() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("node(1..3). in(1,X) :- &neighbors[1](X), node(X)."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set expected = AnswerSetsParser.parse("{ in(1,2), in(1,3), node(1), node(2), node(3) }"); Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -300,10 +300,10 @@ public void smallGraphSingleNeighbor() throws Exception { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphSingleNeighborNoTerm() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("success :- &neighbors[1], not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set expected = AnswerSetsParser.parse("{ success }"); Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -335,9 +335,9 @@ public void withExternalSubtype() throws Exception { new MethodPredicateInterpretation(this.getClass().getMethod("thinger", Thingy.class)), singletonList(Terms.newConstant(thingy)), emptyList()), true))); - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); - ASPCore2Program prog = Programs.newASPCore2Program(singletonList(rule), emptyList(), Programs.newInlineDirectives()); + InputProgram prog = Programs.newInputProgram(singletonList(rule), emptyList(), Programs.newInlineDirectives()); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").instance("x").build())); @@ -346,10 +346,10 @@ public void withExternalSubtype() throws Exception { @Test public void withExternalViaAnnotation() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1]."); cfg.addPredicateMethods(Externals.scan(this.getClass())); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); @@ -372,10 +372,10 @@ public void errorDuplicateExternal() { @Test public void withNativeExternal() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isTwo[2]."); cfg.addPredicateMethod("isTwo", Externals.processPredicate((Integer t) -> t == 2)); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); Set actual = system.solve(prog).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").build())); @@ -385,10 +385,10 @@ public void withNativeExternal() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted1() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = new AlphaFactory().newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], &isOne[1]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); int before = invocations; Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -406,7 +406,7 @@ public void withExternalInvocationCounted2() throws Exception { Alpha system = new AlphaImpl(); InputConfig cfg = InputConfig.forString("a. b :- &isOne[1], &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); int before = invocations; Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -424,7 +424,7 @@ public void withExternalInvocationCounted3() throws Exception { Alpha system = new AlphaImpl(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], not &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); - ASPCore2Program prog = system.readProgram(cfg); + InputProgram prog = system.readProgram(cfg); int before = invocations; Set actual = system.solve(prog).collect(Collectors.toSet()); @@ -440,7 +440,7 @@ public void withExternalInvocationCounted3() throws Exception { @SuppressWarnings("unchecked") public void programWithExternalStringStuff() throws IOException { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgram(InputConfig.forString(STRINGSTUFF_ASP)); + InputProgram prog = alpha.readProgram(InputConfig.forString(STRINGSTUFF_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); // Verify every result string has length 6 and contains "foo" for (AnswerSet as : answerSets) { @@ -456,7 +456,7 @@ public void programWithExternalStringStuff() throws IOException { @SuppressWarnings("unchecked") public void withNegatedExternal() throws IOException { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgram(InputConfig.forString(NEGATED_EXTERNAL_ASP)); + InputProgram prog = alpha.readProgram(InputConfig.forString(NEGATED_EXTERNAL_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); assertEquals(31, answerSets.size()); // Verify every result string has length 6 and contains "foo" @@ -474,7 +474,7 @@ public void withNegatedExternal() throws IOException { public void reifyInput() { String aspInput = "p(X) :- q(X), not r(X)."; Alpha system = new AlphaImpl(); - ASPCore2Program input = system.readProgramString(aspInput); + InputProgram input = system.readProgramString(aspInput); Set reified = system.reify(input); Set reifiedPredicates = reified.stream() @@ -514,7 +514,7 @@ public void basicUsageWithString() throws Exception { public void filterTest() { String progstr = "a. b. c. d :- c. e(a, b) :- d."; Alpha system = new AlphaImpl(); - ASPCore2Program prog = system.readProgramString(progstr); + InputProgram prog = system.readProgramString(progstr); Set actual = system.solve(prog, (p) -> p.equals(Predicates.getPredicate("a", 0)) || p.equals(Predicates.getPredicate("e", 2))) .collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("a").predicate("e").symbolicInstance("a", "b").build())); @@ -531,7 +531,7 @@ public void disableStratifiedEvalTest() { SystemConfig cfg = new SystemConfig(); cfg.setEvaluateStratifiedPart(false); AlphaImpl system = new AlphaImpl(cfg); - ASPCore2Program input = system.readProgramString(progstr); + InputProgram input = system.readProgramString(progstr); NormalProgram normal = system.normalizeProgram(input); CompiledProgram preprocessed = system.performProgramPreprocessing(normal); assertFalse(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), @@ -547,7 +547,7 @@ public void enableStratifiedEvalTest() { String progstr = "p(a). q(X) :- p(X)."; SystemConfig cfg = new SystemConfig(); AlphaImpl system = new AlphaImpl(cfg); - ASPCore2Program input = system.readProgramString(progstr); + InputProgram input = system.readProgramString(progstr); NormalProgram normal = system.normalizeProgram(input); CompiledProgram preprocessed = system.performProgramPreprocessing(normal); assertTrue(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), @@ -557,7 +557,7 @@ public void enableStratifiedEvalTest() { @Test public void passingUnitTestExpectUnsat() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_EXPECT_UNSAT); + InputProgram prog = alpha.readProgramString(UNIT_TEST_EXPECT_UNSAT); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); } @@ -565,7 +565,7 @@ public void passingUnitTestExpectUnsat() { @Test public void passingUnitTestBasicTest() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_BASIC_TEST); + InputProgram prog = alpha.readProgramString(UNIT_TEST_BASIC_TEST); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); assertEquals(1, testResult.getTestCaseResults().size()); @@ -580,7 +580,7 @@ public void passingUnitTestBasicTest() { @Test public void passingUnitTestMultipleAssertions() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_MORE_ASSERTIONS); + InputProgram prog = alpha.readProgramString(UNIT_TEST_MORE_ASSERTIONS); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); assertEquals(1, testResult.getTestCaseResults().size()); @@ -595,7 +595,7 @@ public void passingUnitTestMultipleAssertions() { @Test public void passingUnitTestMultipleTestCases() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_MORE_TCS); + InputProgram prog = alpha.readProgramString(UNIT_TEST_MORE_TCS); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); assertEquals(2, testResult.getTestCaseResults().size()); @@ -604,7 +604,7 @@ public void passingUnitTestMultipleTestCases() { @Test public void failingAssertionUnitTest() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_FAILING_ASSERTION); + InputProgram prog = alpha.readProgramString(UNIT_TEST_FAILING_ASSERTION); TestResult testResult = alpha.test(prog); assertFalse(testResult.isSuccess()); assertEquals(1, testResult.getTestCaseResults().size()); @@ -619,7 +619,7 @@ public void failingAssertionUnitTest() { @Test public void failingAnswerSetCountUnitTest() { Alpha alpha = new AlphaImpl(); - ASPCore2Program prog = alpha.readProgramString(UNIT_TEST_FAILING_COUNT); + InputProgram prog = alpha.readProgramString(UNIT_TEST_FAILING_COUNT); TestResult testResult = alpha.test(prog); assertFalse(testResult.isSuccess()); assertEquals(1, testResult.getTestCaseResults().size()); @@ -690,7 +690,7 @@ public void problematicRun_3col_1119718541727902_sorted_400() throws IOException List files = new ArrayList<>(); files.add(path.toString()); inputCfg.setFiles(files); - ASPCore2Program prog = system.readProgram(inputCfg); + InputProgram prog = system.readProgram(inputCfg); assertFalse(system.solve(prog).sorted().limit(400).collect(Collectors.toList()).isEmpty()); } @@ -708,7 +708,7 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep List files = new ArrayList<>(); files.add(base.resolve(program).toString()); inputCfg.setFiles(files); - ASPCore2Program prog = system.readProgram(inputCfg); + InputProgram prog = system.readProgram(inputCfg); assertFalse(system.solve(prog).limit(limit).collect(Collectors.toList()).isEmpty()); } @@ -716,11 +716,11 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep @Test public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { final ProgramParser parser = new ProgramParserImpl(); - ASPCore2ProgramBuilder bld = Programs.builder(); + InputProgramBuilder bld = Programs.builder(); bld.accumulate(parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), StandardOpenOption.READ))); bld.accumulate( parser.parse(Files.newInputStream(Paths.get("src", "test", "resources", "HanoiTower_instances", "simple.asp"), StandardOpenOption.READ))); - ASPCore2Program parsedProgram = bld.build(); + InputProgram parsedProgram = bld.build(); SystemConfig config = new SystemConfig(); config.setSolverName("default"); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java index 23457da10..7657b7d40 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java @@ -39,7 +39,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; @@ -101,7 +101,7 @@ private void testHanoiTower(int instance, RegressionTestConfig cfg) throws IOExc } private void testHanoiTower(String instance, RegressionTestConfig cfg) throws IOException { - ASPCore2Program prog = new ProgramParserImpl().parse( + InputProgram prog = new ProgramParserImpl().parse( Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), Paths.get("src", "test", "resources", "HanoiTower_instances", instance + ".asp")); Solver solver = TestUtils.buildSolverForRegressionTest(prog, cfg); @@ -115,7 +115,7 @@ private void testHanoiTower(String instance, RegressionTestConfig cfg) throws IO * for every goal/3 * fact in the input there is a corresponding on/3 atom in the output. */ - private void checkGoal(ASPCore2Program parsedProgram, AnswerSet answerSet) { + private void checkGoal(InputProgram parsedProgram, AnswerSet answerSet) { Predicate ongoal = Predicates.getPredicate("ongoal", 2); Predicate on = Predicates.getPredicate("on", 3); int steps = getSteps(parsedProgram); @@ -131,7 +131,7 @@ private void checkGoal(ASPCore2Program parsedProgram, AnswerSet answerSet) { } } - private int getSteps(ASPCore2Program parsedProgram) { + private int getSteps(InputProgram parsedProgram) { Predicate steps = Predicates.getPredicate("steps", 1); for (Atom atom : parsedProgram.getFacts()) { if (atom.getPredicate().getName().equals(steps.getName()) && atom.getPredicate().getArity() == steps.getArity()) { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java index da9238e66..2f2b91204 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java @@ -42,7 +42,7 @@ import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** * Tests rule transformations described in the following research paper, and their effects on performance: @@ -246,7 +246,7 @@ private InputProgram constructProgramA_TransformationA(int n) { private InputProgram checkNumberOfRulesAndParse(List strRules, int numberOfRules) { assertEquals(numberOfRules, strRules.size()); String strProgram = strRules.stream().collect(Collectors.joining(System.lineSeparator())); - InputProgram parsedProgram = new ASPCore2ProgramParser().parse(strProgram); + InputProgram parsedProgram = new InputProgramParser().parse(strProgram); assertEquals(numberOfRules, parsedProgram.getRules().size()); return parsedProgram; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java index a8d9d79d0..171e0c514 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java @@ -41,7 +41,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -112,7 +112,7 @@ public void testReach_4(SystemConfig cfg) { private void test(String folder, String aspFileName, SystemConfig cfg) throws IOException { @SuppressWarnings("unused") Optional answerSet = buildSolverForRegressionTest( - new ASPCore2ProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) + new InputProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) .stream().findFirst(); // System.out.println(answerSet); // TODO: check correctness of answer set diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java index 070177f4e..6303ec475 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java @@ -39,7 +39,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.ASPCore2ProgramParser; +import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** @@ -61,7 +61,7 @@ public void testRacks(SystemConfig cfg) { private void test(SystemConfig cfg) throws IOException { CharStream programInputStream = CharStreams.fromPath( Paths.get("benchmarks", "siemens", "racks", "racks.lp")); - Solver solver = buildSolverForRegressionTest(new ASPCore2ProgramParser().parse(programInputStream), cfg); + Solver solver = buildSolverForRegressionTest(new InputProgramParser().parse(programInputStream), cfg); @SuppressWarnings("unused") Optional answerSet = solver.stream().findFirst(); // System.out.println(answerSet); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java index c0bfdd991..da84e80a7 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java @@ -44,7 +44,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; @@ -79,7 +79,7 @@ public void testObjectProgram(RegressionTestConfig cfg) { final Atom fact = Atoms.newBasicAtom(Predicates.getPredicate("foo", 1), Terms.newConstant(thingy)); - final ASPCore2Program program = Programs.newASPCore2Program( + final InputProgram program = Programs.newInputProgram( Collections.emptyList(), Collections.singletonList(fact), Programs.newInlineDirectives() diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java index b39232c8c..9c8388297 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java @@ -36,12 +36,12 @@ import org.junit.jupiter.api.Disabled; import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -99,17 +99,17 @@ public void testV300E300(RegressionTestConfig cfg) { } private void testThreeColouring(int nVertices, int nEdges, RegressionTestConfig cfg) { - ASPCore2Program tmpPrg = new ProgramParserImpl().parse( + InputProgram tmpPrg = new ProgramParserImpl().parse( "blue(N) :- v(N), not red(N), not green(N)." + "red(N) :- v(N), not blue(N), not green(N)." + "green(N) :- v(N), not red(N), not blue(N)." + ":- e(N1,N2), blue(N1), blue(N2)." + ":- e(N1,N2), red(N1), red(N2)." + ":- e(N1,N2), green(N1), green(N2)."); - ASPCore2ProgramBuilder prgBuilder = Programs.builder(tmpPrg); + InputProgramBuilder prgBuilder = Programs.builder(tmpPrg); prgBuilder.addFacts(createVertices(nVertices)); prgBuilder.addFacts(createEdges(nVertices, nEdges)); - ASPCore2Program program = prgBuilder.build(); + InputProgram program = prgBuilder.build(); maybeShuffle(program); @SuppressWarnings("unused") @@ -120,7 +120,7 @@ private void testThreeColouring(int nVertices, int nEdges, RegressionTestConfig } @SuppressWarnings("unused") - private void maybeShuffle(ASPCore2Program program) { + private void maybeShuffle(InputProgram program) { // TODO: switch on if different rule orderings in the encoding are desired (e.g. for benchmarking purposes) // FIXME since InputProgram is immutable this needs to be reworked a bit if used diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java index e0ff335a6..8f0c32c05 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java @@ -38,13 +38,13 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -185,13 +185,13 @@ public void testN101(RegressionTestConfig cfg) { } private void testThreeColouring(int n, boolean shuffle, int seed, RegressionTestConfig cfg) { - ASPCore2Program tmpPrg = new ProgramParserImpl() + InputProgram tmpPrg = new ProgramParserImpl() .parse("col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); - ASPCore2ProgramBuilder prgBuilder = Programs.builder().accumulate(tmpPrg); + InputProgramBuilder prgBuilder = Programs.builder().accumulate(tmpPrg); prgBuilder.addFacts(createColors("1", "2", "3")); prgBuilder.addFacts(createVertices(n)); prgBuilder.addFacts(createEdges(n, shuffle, seed)); - ASPCore2Program program = prgBuilder.build(); + InputProgram program = prgBuilder.build(); Solver solver = buildSolverForRegressionTest(program, cfg); @SuppressWarnings("unused") diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java index 370e6fbd0..1470708ca 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java @@ -36,13 +36,13 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; +import at.ac.tuwien.kr.alpha.commons.programs.Programs.InputProgramBuilder; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -99,15 +99,15 @@ public void testN11(RegressionTestConfig cfg) { } private void testThreeColouring(int n, RegressionTestConfig cfg) { - ASPCore2Program tmpPrg = new ProgramParserImpl().parse( + InputProgram tmpPrg = new ProgramParserImpl().parse( "col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); - ASPCore2ProgramBuilder prgBuilder = Programs.builder(tmpPrg); + InputProgramBuilder prgBuilder = Programs.builder(tmpPrg); prgBuilder.addFacts(createColors("red", "blue", "green")); prgBuilder.addFacts(createVertices(n)); prgBuilder.addFacts(createEdges(n)); - ASPCore2Program program = prgBuilder.build(); + InputProgram program = prgBuilder.build(); maybeShuffle(program); @@ -121,7 +121,7 @@ private void testThreeColouring(int n, RegressionTestConfig cfg) { } @SuppressWarnings("unused") - private void maybeShuffle(ASPCore2Program program) { + private void maybeShuffle(InputProgram program) { // FIXME since InputProgram is immutable this needs to be reworked a bit if used // No shuffling here. } From 173f664efacba547864e0716ae450abf6a215e6c Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Mon, 22 Jul 2024 13:21:24 +0200 Subject: [PATCH 95/96] Fix tests after merging master --- .../main/java/at/ac/tuwien/kr/alpha/Main.java | 2 +- .../alpha/app/ComponentGraphWriterTest.java | 2 +- .../alpha/app/DependencyGraphWriterTest.java | 2 +- .../AnswerSetToWorkbookMapperTest.java | 2 +- .../alpha/core/parser/ProgramPartParser.java | 2 +- .../tuwien/kr/alpha/test/AlphaAssertions.java | 1 - .../kr/alpha/test/AnswerSetsParser.java | 2 +- .../kr/alpha/api/impl/AlphaFactory.java | 11 +- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 5 +- .../kr/alpha/AggregateRewritingTest.java | 42 +++-- .../alpha/ArithmeticTermsRewritingTest.java | 5 +- .../FixedInterpretationLiteralsTest.java | 9 +- .../kr/alpha/StratifiedEvaluationTest.java | 167 +++++++++--------- .../kr/alpha/api/impl/AlphaImplTest.java | 111 ++++-------- .../kr/alpha/api/impl/ReificationTest.java | 2 +- .../alpha/regressiontests/HanoiTowerTest.java | 31 ++-- .../HeadBodyTransformationTests.java | 4 +- .../regressiontests/OmigaBenchmarksTest.java | 7 +- .../kr/alpha/regressiontests/RacksTest.java | 6 +- .../kr/alpha/regressiontests/SolverTests.java | 160 ++++++++--------- .../StratifiedEvaluationRegressionTest.java | 10 +- .../ThreeColouringRandomGraphTest.java | 26 +-- .../ThreeColouringTestWithRandom.java | 50 +++--- .../ThreeColouringWheelTest.java | 26 +-- .../util/RegressionTestConfigProvider.java | 6 +- .../util/RegressionTestUtils.java | 10 +- 26 files changed, 337 insertions(+), 364 deletions(-) diff --git a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java index 9fbaccc39..94a8eb285 100644 --- a/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java +++ b/alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/Main.java @@ -86,7 +86,7 @@ public static void main(String[] args) { Main.exitWithMessage(commandLineParser.getUsageMessage(), 1); } - Alpha alpha = new AlphaFactory().newAlpha(cfg.getSystemConfig()); + Alpha alpha = AlphaFactory.newAlpha(cfg.getSystemConfig()); InputProgram program = null; try { diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java index 9c5777159..23655f106 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/ComponentGraphWriterTest.java @@ -54,7 +54,7 @@ public void smokeTest() { "n1 -> n5 [xlabel=\"-\" labeldistance=0.1]" + LS + "n2 -> n5 [xlabel=\"+\" labeldistance=0.1]" + LS + "}" + LS; - Alpha alpha = new AlphaFactory().newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); DebugSolvingContext dbgResult = alpha.prepareDebugSolve(alpha.readProgramString(asp)); ComponentGraph compgraph = dbgResult.getComponentGraph(); ComponentGraphWriter writer = new ComponentGraphWriter(); diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java index a738bf3e0..8d5929e80 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/DependencyGraphWriterTest.java @@ -51,7 +51,7 @@ public void smokeTest() { "n6 -> n4 [xlabel=\"+\" labeldistance=0.1]" + LS + "n6 -> n5 [xlabel=\"+\" labeldistance=0.1]" + LS + "}" + LS; - Alpha alpha = new AlphaFactory().newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); DebugSolvingContext dbgResult = alpha.prepareDebugSolve(alpha.readProgramString(asp)); DependencyGraph depgraph = dbgResult.getDependencyGraph(); DependencyGraphWriter writer = new DependencyGraphWriter(); diff --git a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java index cafb17236..3b156426d 100644 --- a/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java +++ b/alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/mappers/AnswerSetToWorkbookMapperTest.java @@ -47,7 +47,7 @@ public void solveAndWriteWorkbookTest() { + "p(N) :- p(I), N = I + 1, N <= MX, maxP(MX)." + "q(A, B) :- p(A), p(B)."; //@formatter:on - Alpha alpha = new AlphaFactory().newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); List answerSets = alpha.solve(alpha.readProgramString(progstr)).collect(Collectors.toList()); assertEquals(1, answerSets.size()); AnswerSet as = answerSets.get(0); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java index 14a5bc1d9..b115e4cd9 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramPartParser.java @@ -43,7 +43,7 @@ import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; /** - * A parser that, in contrast to {@link ProgramParser}, does not parse full programs but only program parts like + * A parser that, in contrast to {@link at.ac.tuwien.kr.alpha.api.programs.ProgramParser}, does not parse full programs but only program parts like * atoms, terms and such. */ // TODO adapt this and create evolog version diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java index 8c45bf662..cce21dafa 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AlphaAssertions.java @@ -2,7 +2,6 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser; import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; diff --git a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java index 93515666b..34f60e7c5 100644 --- a/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/AnswerSetsParser.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.impl; +package at.ac.tuwien.kr.alpha.test; import java.util.Collections; import java.util.Set; diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index 53d5eb323..dcc85fdec 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -65,7 +65,7 @@ protected ActionImplementationProvider newActionImplementationProvider() { return new DefaultActionImplementationProvider(); } - public Alpha newAlpha(SystemConfig cfg) { + protected Alpha buildInstance(SystemConfig cfg) { ActionImplementationProvider actionImplementationProvider = newActionImplementationProvider(); ProgramParser parser = new ProgramParserImpl(actionImplementationProvider, Collections.emptyMap()); ProgramTransformation programNormalizer = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()); @@ -87,8 +87,13 @@ public Alpha newAlpha(SystemConfig cfg) { } // Create Alpha instance with default config. - public Alpha newAlpha() { - return newAlpha(new SystemConfig()); + public static Alpha newAlpha() { + return AlphaFactory.newAlpha(new SystemConfig()); + } + + public static Alpha newAlpha(SystemConfig cfg) { + AlphaFactory factory = new AlphaFactory(); + return factory.buildInstance(cfg); } } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index c00df590d..b52ab8273 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -3,6 +3,7 @@ import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; @@ -45,7 +46,7 @@ public class ActionsTest { @Test public void helloWorld() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); - Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); assertEquals("Hello World!", alphaFactory.getActionImplementationMock().getStdoutContent()); @@ -61,7 +62,7 @@ public void writeToFile() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); alphaFactory.getActionImplementationMock().setMockedFileOutputs(mockedFileOutputs); ActionImplementationProvider actionProvider = alphaFactory.getActionImplementationMock(); - Alpha alpha = alphaFactory.newAlpha(new SystemConfig()); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram program = alpha.readProgramString(WRITE_TO_FILE); Set answerSets = alpha.solve(program).collect(Collectors.toSet()); LOGGER.debug("Got answer sets: {}", answerSets); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java index 1d11e89d4..e4ca8acf3 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java @@ -1,11 +1,14 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; +package at.ac.tuwien.kr.alpha; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import java.util.function.Function; +import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -31,18 +34,6 @@ public class AggregateRewritingTest { - private static final ProgramParser PARSER = new ProgramParserImpl(); - private static final Function> NORMALIZE_AND_SOLVE = (str) -> { - SystemConfig cfg = new SystemConfig(); - InputProgram prog = PARSER.parse(str); - NormalProgram normalized = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()).apply(prog); - CompiledProgram compiled = InternalProgram.fromNormalProgram(normalized); - AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", compiled, atomStore, cfg.isDebugInternalChecks()); - Solver solver = SolverFactory.getInstance(cfg, atomStore, grounder); - return solver.collectList(); - }; - //@formatter:off // Smoke-test case for "X <= #count{...}" aggregate private static final String CNT_LE1_ASP = @@ -99,9 +90,16 @@ public class AggregateRewritingTest { + " Y = #count { X : p( X ) }, 1 <= #count { X : p( X ) }, Z = #max { W : p( W ) }."; //@formatter:on + // Use an alpha instance with default config for all test cases + private final Alpha alpha = AlphaFactory.newAlpha(); + private final Function> solve = (asp) -> { + InputProgram prog = alpha.readProgramString(asp); + return alpha.solve(prog).collect(Collectors.toList()); + }; + @Test public void countLeSortingGridSimple() { - List answerSets = NORMALIZE_AND_SOLVE.apply(CNT_LE1_ASP); + List answerSets = solve.apply(CNT_LE1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate thing = Predicates.getPredicate("thing", 1); @@ -123,7 +121,7 @@ public void countLeSortingGridSimple() { @Test public void countEqSimple() { - List answerSets = NORMALIZE_AND_SOLVE.apply(CNT_EQ1_ASP); + List answerSets = solve.apply(CNT_EQ1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate thing = Predicates.getPredicate("thing", 1); @@ -141,7 +139,7 @@ public void countEqSimple() { @Test public void countLeCountingGridSimple() { - List answerSets = NORMALIZE_AND_SOLVE.apply(CNT_LE1_ASP); + List answerSets = solve.apply(CNT_LE1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate thing = Predicates.getPredicate("thing", 1); @@ -163,7 +161,7 @@ public void countLeCountingGridSimple() { @Test public void countEqGlobalVars() { - List answerSets = NORMALIZE_AND_SOLVE.apply(VERTEX_DEGREE_ASP); + List answerSets = solve.apply(VERTEX_DEGREE_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate vertexDegree = Predicates.getPredicate("graph_vertex_degree", 3); @@ -182,7 +180,7 @@ public void countEqGlobalVars() { @Test // Test "count eq" and "max eq" together with global vars public void graphVerticesOfMaxDegree() { - List answerSets = NORMALIZE_AND_SOLVE.apply(NUM_MAX_DEGREE_VERTICES_ASP); + List answerSets = solve.apply(NUM_MAX_DEGREE_VERTICES_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate maxDegreeVertices = Predicates.getPredicate("graph_max_degree_vertices", 3); @@ -196,7 +194,7 @@ public void graphVerticesOfMaxDegree() { @Test public void greaterMin() { - List answerSets = NORMALIZE_AND_SOLVE.apply(MIN_GT1_ASP); + List answerSets = solve.apply(MIN_GT1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate greaterMin = Predicates.getPredicate("greater_min_acceptable", 1); @@ -210,7 +208,7 @@ public void greaterMin() { @Test public void sumEquals1() { - List answerSets = NORMALIZE_AND_SOLVE.apply(SUM_EQ1_ASP); + List answerSets = solve.apply(SUM_EQ1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate sumThings = Predicates.getPredicate("sum_things", 1); @@ -224,7 +222,7 @@ public void sumEquals1() { @Test public void sumLessOrEqual1() { - List answerSets = NORMALIZE_AND_SOLVE.apply(SUM_LE1_ASP); + List answerSets = solve.apply(SUM_LE1_ASP); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate boundLe = Predicates.getPredicate("bound_le_sum", 1); @@ -238,7 +236,7 @@ public void sumLessOrEqual1() { @Test @Disabled("Open issue, as dependency analysis includes cyclic output-dependency, which it should not.") public void setComplexEqualityWithGlobals() { - List answerSets = NORMALIZE_AND_SOLVE.apply(COMPLEX_EQUALITY_WITH_GLOBALS); + List answerSets = solve.apply(COMPLEX_EQUALITY_WITH_GLOBALS); assertEquals(1, answerSets.size()); AnswerSet answerSet = answerSets.get(0); Predicate q = Predicates.getPredicate("q", 0); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index e92589302..bbcb22734 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation; +package at.ac.tuwien.kr.alpha; import static java.util.stream.Collectors.toList; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -9,6 +9,7 @@ import java.util.Map; import java.util.Set; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; @@ -23,7 +24,7 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; /** diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java index 690e39777..9915ef7b0 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.api.impl; +package at.ac.tuwien.kr.alpha; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -12,6 +12,7 @@ import java.util.Optional; import java.util.Set; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.Alpha; @@ -23,8 +24,8 @@ import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.externals.AspStandardLibrary; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; public class FixedInterpretationLiteralsTest { @@ -79,7 +80,7 @@ public static Set>> connection(String dummy) { private Map externals; public FixedInterpretationLiteralsTest() { - this.alpha = new AlphaImpl(); + this.alpha = AlphaFactory.newAlpha(); this.externals = new HashMap<>(); this.externals.putAll(Externals.scan(AspStandardLibrary.class)); this.externals.putAll(Externals.scan(FixedInterpretationLiteralsTest.class)); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java index 6c6def131..19ec176cb 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java @@ -25,8 +25,9 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.programs.transformation; +package at.ac.tuwien.kr.alpha; +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -36,7 +37,14 @@ import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.api.Alpha; +import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; +import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; +import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.AnswerSet; @@ -54,7 +62,7 @@ import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.grounder.Grounder; import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; @@ -62,33 +70,24 @@ import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; -import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; public class StratifiedEvaluationTest { - private final ProgramParser parser = new ProgramParserImpl(); - private final NormalizeProgramTransformation normalizer = new NormalizeProgramTransformation(SystemConfig.DEFAULT_AGGREGATE_REWRITING_CONFIG); - private final StratifiedEvaluation evaluator = new StratifiedEvaluation(); - private final Function parseAndEvaluate = (str) -> { - return evaluator.apply(AnalyzedProgram.analyzeNormalProgram(normalizer.apply(parser.parse(str)))); - }; - - private final Function> solveCompiledProg = (prog) -> { - AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, false); - Solver solver = SolverFactory.getInstance(new SystemConfig(), atomStore, grounder); - return solver.collectSet(); - }; + // Alpha instance with default configuration (evolog support and stratified evaluation enabled) + private final Alpha alpha = AlphaFactory.newAlpha(); + /** + * Verifies that facts are not duplicated by stratified evaluation. + */ @Test public void testDuplicateFacts() { String aspStr = "p(a). p(b). q(b). q(X) :- p(X)."; - CompiledProgram evaluated = parseAndEvaluate.apply(aspStr); - Instance qOfB = new Instance(TestUtils.basicAtomWithSymbolicTerms("q", "b").getTerms()); - Set facts = evaluated.getFactsByPredicate().get(Predicates.getPredicate("q", 1)); + DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(alpha.readProgramString(aspStr)); + NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); + BasicAtom qOfB = Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("b")); int numQOfB = 0; - for (Instance at : facts) { - if (at.equals(qOfB)) { + for (Atom fact : evaluated.getFacts()) { + if (fact.equals(qOfB)) { numQOfB++; } } @@ -98,41 +97,39 @@ public void testDuplicateFacts() { @Test public void testEqualityWithConstantTerms() { String aspStr = "equal :- 1 = 1."; - CompiledProgram evaluated = parseAndEvaluate.apply(aspStr); - Atom equal = TestUtils.basicAtomWithSymbolicTerms("equal"); + DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(alpha.readProgramString(aspStr)); + NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); + Atom equal = Atoms.newBasicAtom(Predicates.getPredicate("equal", 0)); assertTrue(evaluated.getFacts().contains(equal)); } @Test public void testEqualityWithVarTerms() { String aspStr = "a(1). a(2). a(3). b(X) :- a(X), X = 1. c(X) :- a(X), X = 2. d(X) :- X = 3, a(X)."; - CompiledProgram evaluated = parseAndEvaluate.apply(aspStr); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("a(1), a(2), a(3), b(1), c(2), d(3)", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(aspStr)).collect(Collectors.toSet()); + assertAnswerSetsEqual("a(1), a(2), a(3), b(1), c(2), d(3)", answerSets); } @Test public void testNonGroundableRule() { String asp = "p(a). q(a, b). s(X, Y) :- p(X), q(X, Y), r(Y)."; - CompiledProgram evaluated = parseAndEvaluate.apply(asp); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("p(a), q(a,b)", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(asp)).collect(Collectors.toSet()); + assertAnswerSetsEqual("p(a), q(a,b)", answerSets); } + @Test public void testCountAggregate() { String asp = "a. b :- 1 <= #count { 1 : a }."; - CompiledProgram evaluated = parseAndEvaluate.apply(asp); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("a, b", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(asp)).collect(Collectors.toSet()); + assertAnswerSetsEqual("a, b", answerSets); } @Test public void testIntervalFact() { String asp = "a(1..3)."; - CompiledProgram evaluated = parseAndEvaluate.apply(asp); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("a(1), a(2), a(3)", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(asp)).collect(Collectors.toSet()); + assertAnswerSetsEqual("a(1), a(2), a(3)", answerSets); } @Test @@ -141,18 +138,18 @@ public void testAggregateSpecial() { + "{ chosenThing(X) : thing(X) }.\n" + "chosenSomething :- chosenThing(X).\n" + ":- not chosenSomething.\n" + ":- chosenThing(X), chosenThing(Y), X != Y.\n" + "allThings :- 3 <= #count{ X : thing(X)}. \n" + "chosenMaxThing :- allThings, chosenThing(3).\n" + ":- not chosenMaxThing."; - CompiledProgram evaluated = parseAndEvaluate.apply(asp); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("allThings"))); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("allThings, thing(1), thing(2), thing(3), chosenMaxThing, chosenSomething, chosenThing(3)", answerSets); + DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(alpha.readProgramString(asp)); + NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); + assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("allThings", 0)))); + Set answerSets = dbgInfo.getSolver().collectSet(); + assertAnswerSetsEqual("allThings, thing(1), thing(2), thing(3), chosenMaxThing, chosenSomething, chosenThing(3)", answerSets); } @Test public void testNegatedFixedInterpretationLiteral() { String asp = "stuff(1). stuff(2). smallStuff(X) :- stuff(X), not X > 1."; - CompiledProgram evaluated = parseAndEvaluate.apply(asp); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("stuff(1), stuff(2), smallStuff(1)", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(asp)).collect(Collectors.toSet()); + assertAnswerSetsEqual("stuff(1), stuff(2), smallStuff(1)", answerSets); } @SuppressWarnings("unused") @@ -161,16 +158,14 @@ public static boolean sayTrue(Object o) { return true; } + @Test public void testNegatedExternalLiteral() throws Exception { String asp = "claimedTruth(bla). truth(X) :- claimedTruth(X), &sayTrue[X]. lie(X) :- claimedTruth(X), not &sayTrue[X]."; Map externals = new HashMap<>(); externals.put("sayTrue", Externals.processPredicateMethod(this.getClass().getMethod("sayTrue", Object.class))); - ProgramParser parserWithExternals = new ProgramParserImpl(); - AnalyzedProgram analyzed = AnalyzedProgram.analyzeNormalProgram(normalizer.apply(parserWithExternals.parse(asp, externals))); - CompiledProgram evaluated = new StratifiedEvaluation().apply(analyzed); - Set answerSets = solveCompiledProg.apply(evaluated); - TestUtils.assertAnswerSetsEqual("claimedTruth(bla), truth(bla)", answerSets); + Set answerSets = alpha.solve(alpha.readProgramString(asp, externals)).collect(Collectors.toSet()); + assertAnswerSetsEqual("claimedTruth(bla), truth(bla)", answerSets); } /** @@ -179,8 +174,11 @@ public void testNegatedExternalLiteral() throws Exception { */ @Test public void testPartnerUnitsProblemTopologicalOrder() throws IOException { - InputProgram prg = parser.parse(StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/pup_topological_order.asp")); - CompiledProgram evaluated = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normalizer.apply(prg))); + InputProgram prg = alpha.readProgramStream( + StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/pup_topological_order.asp"), + new HashMap<>()); + DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(prg); + NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); assertTrue(evaluated.getRules().isEmpty(), "Not all rules eliminated by stratified evaluation"); assertEquals(57, evaluated.getFacts().size()); } @@ -191,6 +189,12 @@ public void testPartnerUnitsProblemTopologicalOrder() throws IOException { * * @throws IOException */ + /** + * Verifies correct handling of negated basic literals in StratifiedEvaluation. + * For details, see comments in test program + * + * @throws IOException + */ @Test public void testNegatedLiteralInRecursiveRule() throws IOException { //@formatter:off @@ -200,51 +204,48 @@ public void testNegatedLiteralInRecursiveRule() throws IOException { + "inc_value(4), inc_value(5), inc_value(6), inc_value(7), " + "inc_value(8)"; //@formatter:on - InputProgram prog = new ProgramParserImpl().parse( + InputProgram prog = alpha.readProgramStream( StratifiedEvaluationTest.class.getResourceAsStream("/partial-eval/recursive_w_negated_condition.asp"), new HashMap<>()); // Run stratified evaluation and solve - CompiledProgram inputStratEval = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normalizer.apply(prog))); - Set asStrat = solveCompiledProg.apply(inputStratEval); - TestUtils.assertAnswerSetsEqual(expectedAnswerSet, asStrat); - - // Solve without stratified evaluation - CompiledProgram inputNoStratEval = InternalProgram.fromNormalProgram(normalizer.apply(prog)); - Set as = solveCompiledProg.apply(inputNoStratEval); - TestUtils.assertAnswerSetsEqual(expectedAnswerSet, as); + DebugSolvingContext dbg = alpha.prepareDebugSolve(prog); + Set as = dbg.getSolver().collectSet(); + assertAnswerSetsEqual(expectedAnswerSet, as); } + @Test public void testRecursiveRanking() { //@formatter:off - String asp = "thing(a).\n" + - "thing(b).\n" + - "thing(c).\n" + - "thing_before(a, b).\n" + - "thing_before(b, c).\n" + - "has_prev_thing(X) :- thing(X), thing_succ(_, X).\n" + - "first_thing(X) :- thing(X), not has_prev_thing(X).\n" + - "thing_not_succ(X, Y) :-\n" + - " thing(X),\n" + - " thing(Y),\n" + - " thing(INTM),\n" + - " thing_before(X, Y),\n" + - " thing_before(X, INTM),\n" + - " thing_before(INTM, X).\n" + - "thing_succ(X, Y) :-\n" + - " thing(X),\n" + - " thing(Y),\n" + - " thing_before(X, Y),\n" + - " not thing_not_succ(X, Y).\n" + - "thing_rank(X, 1) :- first_thing(X).\n" + - "thing_rank(X, R) :-\n" + - " thing(X),\n" + - " thing_succ(Y, X),\n" + - " thing_rank(Y, K),\n" + + String asp = "thing(a).\n" + + "thing(b).\n" + + "thing(c).\n" + + "thing_before(a, b).\n" + + "thing_before(b, c).\n" + + "has_prev_thing(X) :- thing(X), thing_succ(_, X).\n" + + "first_thing(X) :- thing(X), not has_prev_thing(X).\n" + + "thing_not_succ(X, Y) :-\n" + + " thing(X),\n" + + " thing(Y),\n" + + " thing(INTM),\n" + + " thing_before(X, Y),\n" + + " thing_before(X, INTM),\n" + + " thing_before(INTM, X).\n" + + "thing_succ(X, Y) :-\n" + + " thing(X),\n" + + " thing(Y),\n" + + " thing_before(X, Y),\n" + + " not thing_not_succ(X, Y).\n" + + "thing_rank(X, 1) :- first_thing(X).\n" + + "thing_rank(X, R) :-\n" + + " thing(X),\n" + + " thing_succ(Y, X),\n" + + " thing_rank(Y, K),\n" + " R = K + 1."; //@formatter:on - CompiledProgram evaluated = parseAndEvaluate.apply(asp); + DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(alpha.readProgramString(asp)); + NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); Predicate rank = Predicates.getPredicate("thing_rank", 2); BasicAtom rank1 = Atoms.newBasicAtom(rank, Terms.newSymbolicConstant("a"), Terms.newConstant(1)); BasicAtom rank2 = Atoms.newBasicAtom(rank, Terms.newSymbolicConstant("b"), Terms.newConstant(2)); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index 0e4086ea9..c26b6c66d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -33,7 +33,6 @@ import at.ac.tuwien.kr.alpha.api.config.InputConfig; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -54,7 +53,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; +import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.slf4j.Logger; @@ -147,7 +146,7 @@ public static boolean thinger(Thingy thingy) { @Test public void withExternal() throws Exception { - Alpha alpha = new AlphaFactory().newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); InputConfig inputCfg = InputConfig.forString("a :- &isOne[1]."); inputCfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram program = alpha.readProgram(inputCfg); @@ -158,7 +157,7 @@ public void withExternal() throws Exception { @Test public void addsFacts() { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); Thingy a = new Thingy(); Thingy b = new Thingy(); List things = asList(a, b); @@ -171,7 +170,7 @@ public void addsFacts() { @Test public void withExternalTypeConflict() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig inputCfg = InputConfig.forString("a :- &isFoo[\"adsfnfdsf\"]."); inputCfg.addPredicateMethod("isFoo", Externals.processPredicateMethod(this.getClass().getMethod("isFoo", Integer.class))); Set actual = system.solve(system.readProgram(inputCfg)).collect(Collectors.toSet()); @@ -182,32 +181,32 @@ public void withExternalTypeConflict() { @Test public void smallGraph() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). node(3). a :- &connected[1,2]."); inputCfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); InputProgram program = system.readProgram(inputCfg); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser.parse("{ a, node(1), node(2), node(3) }"); + Set expected = AnswerSetsParser.parse("{ a, node(1), node(2), node(3) }"); assertEquals(expected, actual); } @Test public void filterOutput() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig inputCfg = InputConfig.forString("node(1). node(2). outgoing13(X) :- node(X), &getLargeGraphEdges(13,X)."); inputCfg.addPredicateMethod("getLargeGraphEdges", Externals.processPredicate(() -> new HashSet<>(asList(asList(Terms.newConstant(1), Terms.newConstant(2)), asList(Terms.newConstant(2), Terms.newConstant(1)), asList(Terms.newConstant(13), Terms.newConstant(1)))))); InputProgram program = system.readProgram(inputCfg); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = at.ac.tuwien.kr.alpha.api.impl.AnswerSetsParser.parse("{ node(1), node(2), outgoing13(1) }"); + Set expected = AnswerSetsParser.parse("{ node(1), node(2), outgoing13(1) }"); assertEquals(expected, actual); } @Test public void supplier() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicate(() -> singleton(singletonList(Terms.newConstant(1))))); InputProgram prog = system.readProgram(cfg); @@ -224,7 +223,7 @@ public static Set>> bestNode() { @Test public void noInput() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("node(1). a :- &bestNode(X), node(X)."); cfg.addPredicateMethod("bestNode", Externals.processPredicateMethod(this.getClass().getMethod("bestNode"))); InputProgram prog = system.readProgram(cfg); @@ -237,7 +236,7 @@ public void noInput() throws Exception { @Test public void smallGraphWithWrongType() { assertThrows(IllegalArgumentException.class, () -> { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a :- &connected[\"hello\",2]."); cfg.addPredicateMethod("connected", Externals.processPredicate((Integer a, Integer b) -> (a == 1 && b == 2) || (b == 2 || b == 3))); InputProgram prog = system.readProgram(cfg); @@ -263,7 +262,7 @@ public static Set>> coolNode(int node) { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphNoNeighbors() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("noNeighbors(2) :- not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -275,7 +274,7 @@ public void smallGraphNoNeighbors() throws Exception { @Test public void smallGraphCoolNode() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("node(1..2). in(X) :- node(X), &coolNode[X]."); cfg.addPredicateMethod("coolNode", Externals.processPredicateMethod(this.getClass().getMethod("coolNode", int.class))); InputProgram prog = system.readProgram(cfg); @@ -287,7 +286,7 @@ public void smallGraphCoolNode() throws Exception { @Test public void smallGraphSingleNeighbor() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("node(1..3). in(1,X) :- &neighbors[1](X), node(X)."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -300,7 +299,7 @@ public void smallGraphSingleNeighbor() throws Exception { @Test @Disabled("Test program is not safe (external lacking output variables). This should throw some exception.") public void smallGraphSingleNeighborNoTerm() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("success :- &neighbors[1], not &neighbors[2]."); cfg.addPredicateMethod("neighbors", Externals.processPredicateMethod(this.getClass().getMethod("neighbors", int.class))); InputProgram prog = system.readProgram(cfg); @@ -331,11 +330,11 @@ public void withExternalSubtype() throws Exception { Rule rule = Rules.newRule( Heads.newNormalHead(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newConstant("x"))), - singletonList(Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("thinger", 1), + singleton(Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("thinger", 1), new MethodPredicateInterpretation(this.getClass().getMethod("thinger", Thingy.class)), singletonList(Terms.newConstant(thingy)), emptyList()), true))); - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputProgram prog = Programs.newInputProgram(singletonList(rule), emptyList(), Programs.newInlineDirectives()); @@ -346,7 +345,7 @@ public void withExternalSubtype() throws Exception { @Test public void withExternalViaAnnotation() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1]."); cfg.addPredicateMethods(Externals.scan(this.getClass())); InputProgram prog = system.readProgram(cfg); @@ -372,7 +371,7 @@ public void errorDuplicateExternal() { @Test public void withNativeExternal() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isTwo[2]."); cfg.addPredicateMethod("isTwo", Externals.processPredicate((Integer t) -> t == 2)); InputProgram prog = system.readProgram(cfg); @@ -385,7 +384,7 @@ public void withNativeExternal() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted1() throws Exception { - Alpha system = new AlphaFactory().newAlpha(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], &isOne[1]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -403,7 +402,7 @@ public void withExternalInvocationCounted1() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted2() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a. b :- &isOne[1], &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -421,7 +420,7 @@ public void withExternalInvocationCounted2() throws Exception { @Test @Disabled("External atom has state, which is not allowed. Caching of calls makes the number of invocations wrong.") public void withExternalInvocationCounted3() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputConfig cfg = InputConfig.forString("a :- &isOne[1], not &isOne[2]."); cfg.addPredicateMethod("isOne", Externals.processPredicateMethod(this.getClass().getMethod("isOne", int.class))); InputProgram prog = system.readProgram(cfg); @@ -439,7 +438,7 @@ public void withExternalInvocationCounted3() throws Exception { @Test @SuppressWarnings("unchecked") public void programWithExternalStringStuff() throws IOException { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgram(InputConfig.forString(STRINGSTUFF_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); // Verify every result string has length 6 and contains "foo" @@ -455,7 +454,7 @@ public void programWithExternalStringStuff() throws IOException { @Test @SuppressWarnings("unchecked") public void withNegatedExternal() throws IOException { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgram(InputConfig.forString(NEGATED_EXTERNAL_ASP)); Set answerSets = alpha.solve(prog).collect(Collectors.toSet()); assertEquals(31, answerSets.size()); @@ -473,7 +472,7 @@ public void withNegatedExternal() throws IOException { @Test public void reifyInput() { String aspInput = "p(X) :- q(X), not r(X)."; - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputProgram input = system.readProgramString(aspInput); Set reified = system.reify(input); @@ -493,7 +492,7 @@ public void reifyInput() { @Test public void basicUsage() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); Set actual = system.solve(system.readProgram(InputConfig.forString("p(a)."))).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").symbolicInstance("a").build())); assertEquals(expected, actual); @@ -501,7 +500,7 @@ public void basicUsage() throws Exception { @Test public void basicUsageWithString() throws Exception { - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); Set actual = system.solve(system.readProgram(InputConfig.forString("p(\"a\")."))).collect(Collectors.toSet()); Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("p").instance("a").build())); assertEquals(expected, actual); @@ -513,7 +512,7 @@ public void basicUsageWithString() throws Exception { @Test public void filterTest() { String progstr = "a. b. c. d :- c. e(a, b) :- d."; - Alpha system = new AlphaImpl(); + Alpha system = AlphaFactory.newAlpha(); InputProgram prog = system.readProgramString(progstr); Set actual = system.solve(prog, (p) -> p.equals(Predicates.getPredicate("a", 0)) || p.equals(Predicates.getPredicate("e", 2))) .collect(Collectors.toSet()); @@ -521,42 +520,9 @@ public void filterTest() { assertEquals(expected, actual); } - /** - * Verifies that no stratified evaluation is performed up-front when disabled in config. - */ - @Test - public void disableStratifiedEvalTest() { - // Note: This might be cleaner if the test used the debugSolve method from the interface - String progstr = "p(a). q(X) :- p(X)."; - SystemConfig cfg = new SystemConfig(); - cfg.setEvaluateStratifiedPart(false); - AlphaImpl system = new AlphaImpl(cfg); - InputProgram input = system.readProgramString(progstr); - NormalProgram normal = system.normalizeProgram(input); - CompiledProgram preprocessed = system.performProgramPreprocessing(normal); - assertFalse(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), - "Preprocessed program contains fact derived from stratifiable rule, but should not!"); - } - - /** - * Verifies that stratified evaluation is performed up-front if not otherwise configured. - */ - @Test - public void enableStratifiedEvalTest() { - // Note: This might be cleaner if the test used the debugSolve method from the interface - String progstr = "p(a). q(X) :- p(X)."; - SystemConfig cfg = new SystemConfig(); - AlphaImpl system = new AlphaImpl(cfg); - InputProgram input = system.readProgramString(progstr); - NormalProgram normal = system.normalizeProgram(input); - CompiledProgram preprocessed = system.performProgramPreprocessing(normal); - assertTrue(preprocessed.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a"))), - "Preprocessed program does not contain fact derived from stratifiable rule, but should!"); - } - @Test public void passingUnitTestExpectUnsat() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_EXPECT_UNSAT); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); @@ -564,7 +530,7 @@ public void passingUnitTestExpectUnsat() { @Test public void passingUnitTestBasicTest() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_BASIC_TEST); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); @@ -579,7 +545,7 @@ public void passingUnitTestBasicTest() { @Test public void passingUnitTestMultipleAssertions() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_MORE_ASSERTIONS); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); @@ -594,7 +560,7 @@ public void passingUnitTestMultipleAssertions() { @Test public void passingUnitTestMultipleTestCases() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_MORE_TCS); TestResult testResult = alpha.test(prog); assertTrue(testResult.isSuccess()); @@ -603,7 +569,7 @@ public void passingUnitTestMultipleTestCases() { @Test public void failingAssertionUnitTest() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_FAILING_ASSERTION); TestResult testResult = alpha.test(prog); assertFalse(testResult.isSuccess()); @@ -618,7 +584,7 @@ public void failingAssertionUnitTest() { @Test public void failingAnswerSetCountUnitTest() { - Alpha alpha = new AlphaImpl(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram prog = alpha.readProgramString(UNIT_TEST_FAILING_COUNT); TestResult testResult = alpha.test(prog); assertFalse(testResult.isSuccess()); @@ -678,12 +644,11 @@ public void problematicRun_3col_1119718541727902_sorted_400() throws IOException * -DebugEnableInternalChecks -q -g naive -s default -sort -n 400 -i 3col-20-38.txt */ SystemConfig cfg = new SystemConfig(); - cfg.setGrounderName("naive"); cfg.setSolverName("default"); cfg.setNogoodStoreName("alpharoaming"); cfg.setDebugInternalChecks(true); cfg.setSeed(1119718541727902L); - final Alpha system = new AlphaImpl(cfg); + final Alpha system = AlphaFactory.newAlpha(cfg); final Path path = Paths.get("src", "test", "resources", "PreviouslyProblematic").resolve("3col-20-38.txt"); InputConfig inputCfg = new InputConfig(); @@ -698,12 +663,11 @@ public void problematicRun_3col_1119718541727902_sorted_400() throws IOException private void problematicRun(String program, long seed, int limit) throws IOException { final Path base = Paths.get("src", "test", "resources", "PreviouslyProblematic"); SystemConfig cfg = new SystemConfig(); - cfg.setGrounderName("naive"); cfg.setSolverName("default"); cfg.setNogoodStoreName("alpharoaming"); cfg.setDebugInternalChecks(true); cfg.setSeed(seed); - final Alpha system = new AlphaImpl(cfg); + final Alpha system = AlphaFactory.newAlpha(cfg); InputConfig inputCfg = new InputConfig(); List files = new ArrayList<>(); files.add(base.resolve(program).toString()); @@ -729,11 +693,10 @@ public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOE config.setBranchingHeuristic(Heuristic.valueOf("VSIDS")); config.setDebugInternalChecks(true); config.setDisableJustificationSearch(false); - config.setEvaluateStratifiedPart(false); config.setReplayChoices(Arrays.asList(21, 26, 36, 56, 91, 96, 285, 166, 101, 290, 106, 451, 445, 439, 448, 433, 427, 442, 421, 415, 436, 409, 430, 397, 391, 424, 385, 379, 418, 373, 412, 406, 394, 388, 382, 245, 232, 208)); - Alpha alpha = new AlphaImpl(config); + Alpha alpha = AlphaFactory.newAlpha(config); Optional answerSet = alpha.solve(parsedProgram).findFirst(); assertTrue(answerSet.isPresent()); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java index 4ec2ea622..4131b6f52 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/ReificationTest.java @@ -33,7 +33,7 @@ */ public class ReificationTest { - private final Alpha alpha = new AlphaImpl(); + private final Alpha alpha = AlphaFactory.newAlpha(); private static final Map> CMP_OP_IDS; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java index 7657b7d40..13021d7c5 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HanoiTowerTest.java @@ -23,9 +23,9 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.solver; +package at.ac.tuwien.kr.alpha.regressiontests; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.runWithTimeout; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; @@ -33,6 +33,8 @@ import java.util.Optional; import java.util.SortedSet; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import org.junit.jupiter.api.Disabled; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,10 +49,9 @@ import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; /** - * Tests {@link AbstractSolver} using some hanoi tower test cases (see https://en.wikipedia.org/wiki/Tower_of_Hanoi). + * Tests {@link Solver} using some hanoi tower test cases (see Towers of Hanoi). * */ public class HanoiTowerTest { @@ -62,49 +63,49 @@ public class HanoiTowerTest { @RegressionTest @Disabled("disabled to save resources during CI") - public void testInstance1(RegressionTestConfig cfg) { + public void testInstance1(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testHanoiTower(1, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testInstance2(RegressionTestConfig cfg) { + public void testInstance2(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testHanoiTower(2, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testInstance3(RegressionTestConfig cfg) { + public void testInstance3(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testHanoiTower(3, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testInstance4(RegressionTestConfig cfg) { + public void testInstance4(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testHanoiTower(4, cfg)); } @RegressionTest - public void testSimple(RegressionTestConfig cfg) { - TestUtils.ignoreTestForNaiveSolver(cfg); - TestUtils.ignoreTestForNonDefaultDomainIndependentHeuristics(cfg); + public void testSimple(SystemConfig cfg) { + ignoreTestForNaiveSolver(cfg); + ignoreTestForNonDefaultDomainIndependentHeuristics(cfg); long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testHanoiTower("simple", cfg)); } - private void testHanoiTower(int instance, RegressionTestConfig cfg) throws IOException { + private void testHanoiTower(int instance, SystemConfig cfg) throws IOException { testHanoiTower(String.valueOf(instance), cfg); } - private void testHanoiTower(String instance, RegressionTestConfig cfg) throws IOException { + private void testHanoiTower(String instance, SystemConfig cfg) throws IOException { InputProgram prog = new ProgramParserImpl().parse( Paths.get("src", "test", "resources", "HanoiTower_Alpha.asp"), Paths.get("src", "test", "resources", "HanoiTower_instances", instance + ".asp")); - Solver solver = TestUtils.buildSolverForRegressionTest(prog, cfg); + Solver solver = buildSolverForRegressionTest(prog, cfg); Optional answerSet = solver.stream().findFirst(); assertTrue(answerSet.isPresent()); checkGoal(prog, answerSet.get()); @@ -135,7 +136,7 @@ private int getSteps(InputProgram parsedProgram) { Predicate steps = Predicates.getPredicate("steps", 1); for (Atom atom : parsedProgram.getFacts()) { if (atom.getPredicate().getName().equals(steps.getName()) && atom.getPredicate().getArity() == steps.getArity()) { - return Integer.valueOf(atom.getTerms().get(0).toString()); + return Integer.parseInt(atom.getTerms().get(0).toString()); } } throw new IllegalArgumentException("No steps atom found in input program."); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java index 2f2b91204..07f80ac83 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/HeadBodyTransformationTests.java @@ -36,13 +36,13 @@ import java.util.Optional; import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import org.junit.jupiter.api.Disabled; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** * Tests rule transformations described in the following research paper, and their effects on performance: @@ -246,7 +246,7 @@ private InputProgram constructProgramA_TransformationA(int n) { private InputProgram checkNumberOfRulesAndParse(List strRules, int numberOfRules) { assertEquals(numberOfRules, strRules.size()); String strProgram = strRules.stream().collect(Collectors.joining(System.lineSeparator())); - InputProgram parsedProgram = new InputProgramParser().parse(strProgram); + InputProgram parsedProgram = new ProgramParserImpl().parse(strProgram); assertEquals(numberOfRules, parsedProgram.getRules().size()); return parsedProgram; } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java index 171e0c514..9ae96e5cd 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/OmigaBenchmarksTest.java @@ -35,17 +35,18 @@ import java.nio.file.Paths; import java.util.Optional; +import at.ac.tuwien.kr.alpha.api.Solver; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import org.junit.jupiter.api.Disabled; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** - * Tests {@link AbstractSolver} using Omiga benchmark problems. + * Tests {@link Solver} using Omiga benchmark problems. * */ // TODO This is actually a performance benchmark and should not be run with standard unit tests @@ -112,7 +113,7 @@ public void testReach_4(SystemConfig cfg) { private void test(String folder, String aspFileName, SystemConfig cfg) throws IOException { @SuppressWarnings("unused") Optional answerSet = buildSolverForRegressionTest( - new InputProgramParser().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) + new ProgramParserImpl().parse(Files.newInputStream(Paths.get("benchmarks", "omiga", "omiga-testcases", folder, aspFileName))), cfg) .stream().findFirst(); // System.out.println(answerSet); // TODO: check correctness of answer set diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java index 6303ec475..7fd811e8a 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/RacksTest.java @@ -32,6 +32,7 @@ import java.nio.file.Paths; import java.util.Optional; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.junit.jupiter.api.Disabled; @@ -39,11 +40,10 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; /** - * Tests {@link AbstractSolver} using a racks configuration problem. + * Tests {@link Solver} using a racks configuration problem. * */ // TODO This is a functional test and should not be run with standard unit tests @@ -61,7 +61,7 @@ public void testRacks(SystemConfig cfg) { private void test(SystemConfig cfg) throws IOException { CharStream programInputStream = CharStreams.fromPath( Paths.get("benchmarks", "siemens", "racks", "racks.lp")); - Solver solver = buildSolverForRegressionTest(new InputProgramParser().parse(programInputStream), cfg); + Solver solver = buildSolverForRegressionTest(new ProgramParserImpl().parse(programInputStream), cfg); @SuppressWarnings("unused") Optional answerSet = solver.stream().findFirst(); // System.out.println(answerSet); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java index da84e80a7..c992ae820 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java @@ -25,16 +25,11 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.solver; +package at.ac.tuwien.kr.alpha.regressiontests; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.assertRegressionTestAnswerSet; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.assertRegressionTestAnswerSets; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.assertRegressionTestAnswerSetsWithBase; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.buildSolverForRegressionTest; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.collectRegressionTestAnswerSets; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; import static java.util.Collections.singleton; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; import java.util.Collections; import java.util.HashSet; @@ -44,6 +39,7 @@ import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; @@ -55,9 +51,8 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.grounder.ChoiceGrounder; -import at.ac.tuwien.kr.alpha.core.grounder.DummyGrounder; -import at.ac.tuwien.kr.alpha.core.test.util.AnswerSetsParser; +import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; +import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; public class SolverTests { @@ -74,7 +69,7 @@ public int compareTo(Thingy o) { } @RegressionTest - public void testObjectProgram(RegressionTestConfig cfg) { + public void testObjectProgram(SystemConfig cfg) { final Thingy thingy = new Thingy(); final Atom fact = Atoms.newBasicAtom(Predicates.getPredicate("foo", 1), Terms.newConstant(thingy)); @@ -91,8 +86,8 @@ public void testObjectProgram(RegressionTestConfig cfg) { } @RegressionTest - public void testFactsOnlyProgram(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void testFactsOnlyProgram(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "p(a). p(b). foo(13). foo(16). q(a). q(c).", @@ -101,8 +96,8 @@ public void testFactsOnlyProgram(RegressionTestConfig cfg) { } @RegressionTest - public void testSimpleRule(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void testSimpleRule(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "p(a). p(b). r(X) :- p(X).", @@ -111,8 +106,8 @@ public void testSimpleRule(RegressionTestConfig cfg) { } @RegressionTest - public void testSimpleRuleWithGroundPart(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void testSimpleRuleWithGroundPart(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "p(1)." + "p(2)." + @@ -123,8 +118,8 @@ public void testSimpleRuleWithGroundPart(RegressionTestConfig cfg) { } @RegressionTest - public void testProgramZeroArityPredicates(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void testProgramZeroArityPredicates(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "a. p(X) :- b, r(X).", @@ -133,7 +128,7 @@ public void testProgramZeroArityPredicates(RegressionTestConfig cfg) { } @RegressionTest - public void testChoiceGroundProgram(RegressionTestConfig cfg) { + public void testChoiceGroundProgram(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- not b. b :- not a.", @@ -144,7 +139,7 @@ public void testChoiceGroundProgram(RegressionTestConfig cfg) { } @RegressionTest - public void testChoiceProgramNonGround(RegressionTestConfig cfg) { + public void testChoiceProgramNonGround(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "dom(1). dom(2). dom(3)." + @@ -165,7 +160,7 @@ public void testChoiceProgramNonGround(RegressionTestConfig cfg) { } @RegressionTest - public void choiceProgram3Way(RegressionTestConfig cfg) { + public void choiceProgram3Way(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- not b, not c." + @@ -179,12 +174,12 @@ public void choiceProgram3Way(RegressionTestConfig cfg) { } @RegressionTest - public void emptyProgramYieldsEmptyAnswerSet(RegressionTestConfig cfg) { + public void emptyProgramYieldsEmptyAnswerSet(SystemConfig cfg) { assertRegressionTestAnswerSets(cfg, "", ""); } @RegressionTest - public void chooseMultipleAnswerSets(RegressionTestConfig cfg) { + public void chooseMultipleAnswerSets(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- not nota." + @@ -206,8 +201,8 @@ public void chooseMultipleAnswerSets(RegressionTestConfig cfg) { } @RegressionTest - public void builtinAtoms(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void builtinAtoms(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "dom(1). dom(2). dom(3). dom(4). dom(5)." + "p(X) :- dom(X), X = 4." + @@ -218,8 +213,8 @@ public void builtinAtoms(RegressionTestConfig cfg) { } @RegressionTest - public void builtinAtomsGroundRule(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void builtinAtomsGroundRule(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "a :- 13 != 4." + "b :- 2 != 3, 2 = 3." + @@ -231,8 +226,8 @@ public void builtinAtomsGroundRule(RegressionTestConfig cfg) { @RegressionTest - public void choiceProgramConstraintSimple(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void choiceProgramConstraintSimple(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "fact(a).\n" + "choice(either, X) :- fact(X), not choice(or, X).\n" + @@ -244,8 +239,8 @@ public void choiceProgramConstraintSimple(RegressionTestConfig cfg) { } @RegressionTest - public void choiceProgramConstraintSimple2(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void choiceProgramConstraintSimple2(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "fact(a).\n" + "desired(either).\n" + @@ -258,7 +253,7 @@ public void choiceProgramConstraintSimple2(RegressionTestConfig cfg) { } @RegressionTest - public void choiceProgramConstraint(RegressionTestConfig cfg) { + public void choiceProgramConstraint(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "eq(1,1)." + @@ -284,7 +279,7 @@ public void choiceProgramConstraint(RegressionTestConfig cfg) { } @RegressionTest - public void choiceProgramConstraintPermutation(RegressionTestConfig cfg) { + public void choiceProgramConstraintPermutation(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "eq(1,1)." + @@ -310,8 +305,8 @@ public void choiceProgramConstraintPermutation(RegressionTestConfig cfg) { } @RegressionTest - public void simpleNoPropagation(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void simpleNoPropagation(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "val(1,1)." + "val(2,2)." + @@ -322,7 +317,7 @@ public void simpleNoPropagation(RegressionTestConfig cfg) { } @RegressionTest - public void choiceAndPropagationAfterwards(RegressionTestConfig cfg) { + public void choiceAndPropagationAfterwards(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "node(a)." + @@ -341,7 +336,7 @@ public void choiceAndPropagationAfterwards(RegressionTestConfig cfg) { } @RegressionTest - public void choiceAndConstraints(RegressionTestConfig cfg) { + public void choiceAndConstraints(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "node(a)." + @@ -360,13 +355,13 @@ public void choiceAndConstraints(RegressionTestConfig cfg) { } @RegressionTest - public void testUnsatisfiableProgram(RegressionTestConfig cfg) { + public void testUnsatisfiableProgram(SystemConfig cfg) { assertRegressionTestAnswerSets(cfg, "p(a). p(b). :- p(a), p(b)."); } @RegressionTest - public void testFunctionTermEquality(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void testFunctionTermEquality(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "r1(f(a,b)). r2(f(a,b)). a :- r1(X), r2(Y), X = Y.", @@ -375,7 +370,7 @@ public void testFunctionTermEquality(RegressionTestConfig cfg) { } @RegressionTest - public void builtinInequality(RegressionTestConfig cfg) { + public void builtinInequality(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "location(a1)." + @@ -398,7 +393,7 @@ public void builtinInequality(RegressionTestConfig cfg) { } @RegressionTest - public void choiceConstraintsInequality(RegressionTestConfig cfg) { + public void choiceConstraintsInequality(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "assign(L, R) :- not nassign(L, R), possible(L, R)." + @@ -456,7 +451,7 @@ public void choiceConstraintsInequality(RegressionTestConfig cfg) { } @RegressionTest - public void sameVariableTwiceInAtom(RegressionTestConfig cfg) { + public void sameVariableTwiceInAtom(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "p(a, a)." + @@ -467,7 +462,7 @@ public void sameVariableTwiceInAtom(RegressionTestConfig cfg) { } @RegressionTest - public void sameVariableTwiceInAtomConstraint(RegressionTestConfig cfg) { + public void sameVariableTwiceInAtomConstraint(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "p(a, a)." + @@ -476,7 +471,7 @@ public void sameVariableTwiceInAtomConstraint(RegressionTestConfig cfg) { } @RegressionTest - public void noPositiveSelfFounding(RegressionTestConfig cfg) { + public void noPositiveSelfFounding(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- b." + @@ -486,7 +481,7 @@ public void noPositiveSelfFounding(RegressionTestConfig cfg) { } @RegressionTest - public void noPositiveCycleSelfFoundingChoice(RegressionTestConfig cfg) { + public void noPositiveCycleSelfFoundingChoice(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "c :- not d." + @@ -498,8 +493,8 @@ public void noPositiveCycleSelfFoundingChoice(RegressionTestConfig cfg) { } @RegressionTest - public void conflictFromUnaryNoGood(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void conflictFromUnaryNoGood(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "d(b)." + "sel(X) :- not nsel(X), d(X)." + @@ -512,7 +507,7 @@ public void conflictFromUnaryNoGood(RegressionTestConfig cfg) { } @RegressionTest - public void intervalsInFacts(RegressionTestConfig cfg) { + public void intervalsInFacts(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a." + @@ -549,7 +544,7 @@ public void intervalsInFacts(RegressionTestConfig cfg) { } @RegressionTest - public void intervalInRules(RegressionTestConfig cfg) { + public void intervalInRules(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- 3 = 1..4 ." + @@ -570,7 +565,7 @@ public void intervalInRules(RegressionTestConfig cfg) { } @RegressionTest - public void emptyIntervals(RegressionTestConfig cfg) { + public void emptyIntervals(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "p(3..1)." + @@ -581,7 +576,7 @@ public void emptyIntervals(RegressionTestConfig cfg) { } @RegressionTest - public void intervalInFunctionTermsInRules(RegressionTestConfig cfg) { + public void intervalInFunctionTermsInRules(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "a :- q(f(1..3,g(4..5)))." + @@ -606,8 +601,8 @@ public void intervalInFunctionTermsInRules(RegressionTestConfig cfg) { } @RegressionTest - public void groundAtomInRule(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void groundAtomInRule(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "p :- dom(X), q, q2." + "dom(1)." + @@ -622,7 +617,7 @@ public void groundAtomInRule(RegressionTestConfig cfg) { } @RegressionTest - public void simpleChoiceRule(RegressionTestConfig cfg) { + public void simpleChoiceRule(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "{ a; b; c} :- d." + @@ -641,7 +636,7 @@ public void simpleChoiceRule(RegressionTestConfig cfg) { } @RegressionTest - public void conditionalChoiceRule(RegressionTestConfig cfg) { + public void conditionalChoiceRule(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "dom(1..3)." + @@ -665,7 +660,7 @@ public void conditionalChoiceRule(RegressionTestConfig cfg) { } @RegressionTest - public void doubleChoiceRule(RegressionTestConfig cfg) { + public void doubleChoiceRule(SystemConfig cfg) { Solver solver = buildSolverForRegressionTest("{ a }. { a }.", cfg); // Make sure that no superfluous answer sets that only differ on hidden atoms occur. List actual = solver.collectList(); @@ -674,8 +669,8 @@ public void doubleChoiceRule(RegressionTestConfig cfg) { } @RegressionTest - public void simpleArithmetics(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void simpleArithmetics(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "eight(X) :- X = 4 + 5 - 1." + "three(X) :- X = Z, Y = 1..10, Z = Y / 3, Z > 2, Z < 4.", @@ -684,8 +679,8 @@ public void simpleArithmetics(RegressionTestConfig cfg) { } @RegressionTest - public void arithmeticsMultiplicationBeforeAddition(RegressionTestConfig cfg) { - assertRegressionTestAnswerSet( + public void arithmeticsMultiplicationBeforeAddition(SystemConfig cfg) { + assertRegressionTestAnswerSets( cfg, "seven(X) :- 1+2 * 3 = X.", @@ -696,7 +691,7 @@ public void arithmeticsMultiplicationBeforeAddition(RegressionTestConfig cfg) { * Tests the fix for issue #101 */ @RegressionTest - public void involvedUnsatisfiableProgram(RegressionTestConfig cfg) { + public void involvedUnsatisfiableProgram(SystemConfig cfg) { assertRegressionTestAnswerSets( cfg, "x :- c1, c2, not x." + @@ -711,7 +706,7 @@ public void involvedUnsatisfiableProgram(RegressionTestConfig cfg) { } @RegressionTest - public void instanceEnumerationAtom(RegressionTestConfig cfg) { + public void instanceEnumerationAtom(SystemConfig cfg) { Set answerSets = buildSolverForRegressionTest("# enumeration_predicate_is enum." + "dom(1). dom(2). dom(3)." + "p(X) :- dom(X)." + @@ -728,7 +723,7 @@ public void instanceEnumerationAtom(RegressionTestConfig cfg) { } @RegressionTest - public void instanceEnumerationArbitraryTerms(RegressionTestConfig cfg) { + public void instanceEnumerationArbitraryTerms(SystemConfig cfg) { Set answerSets = buildSolverForRegressionTest("# enumeration_predicate_is enum." + "dom(a). dom(f(a,b)). dom(d)." + "p(X) :- dom(X)." + @@ -745,7 +740,7 @@ public void instanceEnumerationArbitraryTerms(RegressionTestConfig cfg) { } @RegressionTest - public void instanceEnumerationMultipleIdentifiers(RegressionTestConfig cfg) { + public void instanceEnumerationMultipleIdentifiers(SystemConfig cfg) { Set answerSets = buildSolverForRegressionTest("# enumeration_predicate_is enum." + "dom(a). dom(b). dom(c). dom(d)." + "p(X) :- dom(X)." + @@ -765,15 +760,15 @@ public void instanceEnumerationMultipleIdentifiers(RegressionTestConfig cfg) { } private void assertPropositionalPredicateFalse(AnswerSet answerSet, Predicate predicate) { - assertEquals(null, answerSet.getPredicateInstances(predicate)); + assertNull(answerSet.getPredicateInstances(predicate)); } private void assertEnumerationPositions(SortedSet positions, int numPositions) { assertEquals(numPositions, positions.size()); - boolean usedPositions[] = new boolean[numPositions]; + boolean[] usedPositions = new boolean[numPositions]; for (Atom position : positions) { @SuppressWarnings("unchecked") - Integer atomPos = ((ConstantTerm) position.getTerms().get(1)).getObject() - 1; + int atomPos = ((ConstantTerm) position.getTerms().get(1)).getObject() - 1; assertTrue(atomPos < numPositions); usedPositions[atomPos] = true; } @@ -783,7 +778,7 @@ private void assertEnumerationPositions(SortedSet positions, int numPositi } @RegressionTest - public void smallCardinalityAggregate(RegressionTestConfig cfg) { + public void smallCardinalityAggregate(SystemConfig cfg) { assertRegressionTestAnswerSetsWithBase( cfg, "dom(1..3)." + @@ -804,16 +799,17 @@ public void smallCardinalityAggregate(RegressionTestConfig cfg) { ); } - @RegressionTest - public void dummyGrounder(RegressionTestConfig cfg) { - AtomStore atomStore = new AtomStoreImpl(); - assertEquals(DummyGrounder.EXPECTED, buildSolverForRegressionTest(atomStore, new DummyGrounder(atomStore), cfg).collectSet()); - } - - @RegressionTest - public void choiceGrounder(RegressionTestConfig cfg) { - AtomStore atomStore = new AtomStoreImpl(); - assertEquals(ChoiceGrounder.EXPECTED, buildSolverForRegressionTest(atomStore, new ChoiceGrounder(atomStore), cfg).collectSet()); - } + // TODO these look obsolete - confirm if they can be removed +// @RegressionTest +// public void dummyGrounder(SystemConfig cfg) { +// AtomStore atomStore = new AtomStoreImpl(); +// assertEquals(DummyGrounder.EXPECTED, buildSolverForRegressionTest(atomStore, new DummyGrounder(atomStore), cfg).collectSet()); +// } +// +// @RegressionTest +// public void choiceGrounder(SystemConfig cfg) { +// AtomStore atomStore = new AtomStoreImpl(); +// assertEquals(ChoiceGrounder.EXPECTED, buildSolverForRegressionTest(atomStore, new ChoiceGrounder(atomStore), cfg).collectSet()); +// } } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java index 4884832c2..db0f40009 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java @@ -10,6 +10,8 @@ import java.util.Set; import java.util.function.Consumer; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -26,8 +28,6 @@ import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; // TODO This is a functional test and should not be run with standard unit tests public class StratifiedEvaluationRegressionTest { @@ -113,7 +113,7 @@ public void runTest(String aspString, Consumer programVerifier, LOGGER.debug("Testing ASP String {}", aspString); // Parse and pre-evaluate program // Alpha instance with default config, stratified evaluation enabled - Alpha alpha = new AlphaFactory().newAlpha(); + Alpha alpha =AlphaFactory.newAlpha(); InputProgram input = alpha.readProgramString(aspString); DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(input); NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); @@ -129,7 +129,7 @@ private static void verifyProgramBasic(NormalProgram evaluated) { assertFactsContainedInProgram(evaluated, Atoms.newBasicAtom(Predicates.getPredicate("a", 0)), Atoms.newBasicAtom(Predicates.getPredicate("b", 0))); assertEquals(2, evaluated.getFacts().size()); - assertTrue(evaluated.getRules().size() == 0); + assertTrue(evaluated.getRules().isEmpty()); } private static void verifyAnswerSetsBasic(Set answerSets) { @@ -140,7 +140,7 @@ private static void verifyProgramBasicMultiInstance(NormalProgram evaluated) { assertFactsContainedInProgram(evaluated, Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("a")), Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newSymbolicConstant("b"))); - assertTrue(evaluated.getRules().size() == 0); + assertTrue(evaluated.getRules().isEmpty()); } private static void verifyAnswerSetsBasicMultiInstance(Set answerSets) { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java index 9c8388297..1740d5133 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringRandomGraphTest.java @@ -23,16 +23,15 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.solver; - -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.buildSolverForRegressionTest; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.runWithTimeout; +package at.ac.tuwien.kr.alpha.regressiontests; import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.Random; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import org.junit.jupiter.api.Disabled; import at.ac.tuwien.kr.alpha.api.AnswerSet; @@ -46,59 +45,62 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.buildSolverForRegressionTest; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.runWithTimeout; + public class ThreeColouringRandomGraphTest { private static final long DEBUG_TIMEOUT_FACTOR = 5; @RegressionTest - public void testV3E3(RegressionTestConfig cfg) { + public void testV3E3(SystemConfig cfg) { long timeout = 1000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(3, 3, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV10E18(RegressionTestConfig cfg) { + public void testV10E18(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, 18, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV20E38(RegressionTestConfig cfg) { + public void testV20E38(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(20, 38, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV30E48(RegressionTestConfig cfg) { + public void testV30E48(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(30, 48, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV200E300(RegressionTestConfig cfg) { + public void testV200E300(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(200, 300, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV300E200(RegressionTestConfig cfg) { + public void testV300E200(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(300, 200, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testV300E300(RegressionTestConfig cfg) { + public void testV300E300(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(300, 300, cfg)); } - private void testThreeColouring(int nVertices, int nEdges, RegressionTestConfig cfg) { + private void testThreeColouring(int nVertices, int nEdges, SystemConfig cfg) { InputProgram tmpPrg = new ProgramParserImpl().parse( "blue(N) :- v(N), not red(N), not green(N)." + "red(N) :- v(N), not blue(N), not green(N)." + diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java index 8f0c32c05..7af25b780 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringTestWithRandom.java @@ -23,10 +23,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.solver; - -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.buildSolverForRegressionTest; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.runWithTimeout; +package at.ac.tuwien.kr.alpha.regressiontests; import java.util.ArrayList; import java.util.Collections; @@ -34,6 +31,8 @@ import java.util.Optional; import java.util.Random; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import org.junit.jupiter.api.Disabled; import at.ac.tuwien.kr.alpha.api.AnswerSet; @@ -49,8 +48,11 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.buildSolverForRegressionTest; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.runWithTimeout; + /** - * Tests {@link AbstractSolver} using some three-coloring test cases, as described in: + * Tests {@link Solver} using some three-coloring test cases, as described in: * Lefèvre, Claire; Béatrix, Christopher; Stéphan, Igor; Garcia, Laurent (2017): * ASPeRiX, a first-order forward chaining approach for answer set computing. * In Theory and Practice of Logic Programming, pp. 1-45. DOI: @@ -61,130 +63,130 @@ public class ThreeColouringTestWithRandom { private static final long DEBUG_TIMEOUT_FACTOR = 5; @RegressionTest - public void testN3(RegressionTestConfig cfg) { + public void testN3(SystemConfig cfg) { long timeout = 3000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(3, false, 0, cfg)); } @RegressionTest - public void testN4(RegressionTestConfig cfg) { + public void testN4(SystemConfig cfg) { long timeout = 4000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(4, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN5(RegressionTestConfig cfg) { + public void testN5(SystemConfig cfg) { long timeout = 5000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(5, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN6(RegressionTestConfig cfg) { + public void testN6(SystemConfig cfg) { long timeout = 6000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(6, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN7(RegressionTestConfig cfg) { + public void testN7(SystemConfig cfg) { long timeout = 7000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(7, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN8(RegressionTestConfig cfg) { + public void testN8(SystemConfig cfg) { long timeout = 8000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(8, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN9(RegressionTestConfig cfg) { + public void testN9(SystemConfig cfg) { long timeout = 9000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(9, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN10(RegressionTestConfig cfg) { + public void testN10(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN10Random0(RegressionTestConfig cfg) { + public void testN10Random0(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, true, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN10Random1(RegressionTestConfig cfg) { + public void testN10Random1(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, true, 1, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN10Random2(RegressionTestConfig cfg) { + public void testN10Random2(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, true, 2, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN10Random3(RegressionTestConfig cfg) { + public void testN10Random3(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(10, true, 3, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN19(RegressionTestConfig cfg) { + public void testN19(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(19, false, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN19Random0(RegressionTestConfig cfg) { + public void testN19Random0(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(19, true, 0, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN19Random1(RegressionTestConfig cfg) { + public void testN19Random1(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(19, true, 1, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN19Random2(RegressionTestConfig cfg) { + public void testN19Random2(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(19, true, 2, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN19Random3(RegressionTestConfig cfg) { + public void testN19Random3(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(19, true, 3, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN101(RegressionTestConfig cfg) { + public void testN101(SystemConfig cfg) { long timeout = 10000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(101, false, 0, cfg)); } - private void testThreeColouring(int n, boolean shuffle, int seed, RegressionTestConfig cfg) { + private void testThreeColouring(int n, boolean shuffle, int seed, SystemConfig cfg) { InputProgram tmpPrg = new ProgramParserImpl() .parse("col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + ":- e(V,U), col(V,C), col(U,C)."); InputProgramBuilder prgBuilder = Programs.builder().accumulate(tmpPrg); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java index 1470708ca..a3ad1c447 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/ThreeColouringWheelTest.java @@ -23,15 +23,14 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.solver; - -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.buildSolverForRegressionTest; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.runWithTimeout; +package at.ac.tuwien.kr.alpha.regressiontests; import java.util.ArrayList; import java.util.List; import java.util.Optional; +import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import org.junit.jupiter.api.Disabled; import at.ac.tuwien.kr.alpha.api.AnswerSet; @@ -47,8 +46,11 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.buildSolverForRegressionTest; +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.runWithTimeout; + /** - * Tests {@link AbstractSolver} using some three-coloring test cases, as described in: + * Tests {@link Solver} using some three-coloring test cases, as described in: * Lefèvre, Claire; Béatrix, Christopher; Stéphan, Igor; Garcia, Laurent (2017): * ASPeRiX, a first-order forward chaining approach for answer set computing. * In Theory and Practice of Logic Programming, pp. 1-45. @@ -59,46 +61,46 @@ public class ThreeColouringWheelTest { private static final long DEBUG_TIMEOUT_FACTOR = 5; @RegressionTest - public void testN4(RegressionTestConfig cfg) { + public void testN4(SystemConfig cfg) { long timeout = 1000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(4, cfg)); } @RegressionTest - public void testN5(RegressionTestConfig cfg) { + public void testN5(SystemConfig cfg) { long timeout = 1000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(5, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN6(RegressionTestConfig cfg) { + public void testN6(SystemConfig cfg) { long timeout = 6000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(6, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN3(RegressionTestConfig cfg) { + public void testN3(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(3, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN7(RegressionTestConfig cfg) { + public void testN7(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(7, cfg)); } @RegressionTest @Disabled("disabled to save resources during CI") - public void testN11(RegressionTestConfig cfg) { + public void testN11(SystemConfig cfg) { long timeout = 60000L; runWithTimeout(cfg, timeout, DEBUG_TIMEOUT_FACTOR, () -> testThreeColouring(11, cfg)); } - private void testThreeColouring(int n, RegressionTestConfig cfg) { + private void testThreeColouring(int n, SystemConfig cfg) { InputProgram tmpPrg = new ProgramParserImpl().parse( "col(V,C) :- v(V), c(C), not ncol(V,C)." + "ncol(V,C) :- col(V,D), c(C), C != D." + diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java index 4d5823aa1..93a5e3ad7 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestConfigProvider.java @@ -21,7 +21,7 @@ public class RegressionTestConfigProvider { private static final boolean DEFAULT_ENABLE_DEBUG_CHECKS = false; /** - * Creates a list of {@link RegressionTestConfig}s with all config combinations that are to be tested im methods tagged using + * Creates a list of {@link SystemConfig}s with all config combinations that are to be tested im methods tagged using * "RegressionTest" annotation. * Exact number of combinations depends on the "CI" environment variable that can be used to signal that a test is being run in a CI * environment. @@ -80,7 +80,7 @@ private static List buildConfigs() { } /** - * Provides {@link RegressionTestConfig}s specifically for tests concerned with AggregateRewriting. + * Provides {@link SystemConfig}s specifically for tests concerned with AggregateRewriting. * All parameters fixed to default values except stratified evaluation, sorting grid encoding for count rewriting * and negative sum element support. * @@ -135,7 +135,7 @@ public static List provideAggregateTestConfigs() { return retVal; } - private static final String[] nonDeprecatedHeuristics() { + private static String[] nonDeprecatedHeuristics() { final List nonDeprecatedHeuristicsNames = new ArrayList<>(); for (Field field : Heuristic.class.getFields()) { if (field.getAnnotation(Deprecated.class) == null) { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java index 686df4990..0629c8be1 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java @@ -32,30 +32,30 @@ public static void runWithTimeout(SystemConfig cfg, long baseTimeout, long timeo } public static Solver buildSolverForRegressionTest(String programString, SystemConfig cfg) { - Alpha alpha = new AlphaFactory().newAlpha(cfg); + Alpha alpha = AlphaFactory.newAlpha(cfg); InputProgram program = alpha.readProgramString(programString); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } public static Solver buildSolverForRegressionTest(InputProgram program, SystemConfig cfg) { - Alpha alpha = new AlphaFactory().newAlpha(cfg); + Alpha alpha =AlphaFactory.newAlpha(cfg); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } public static Set collectRegressionTestAnswerSets(String program, SystemConfig cfg) { - Alpha alpha = new AlphaFactory().newAlpha(cfg); + Alpha alpha = AlphaFactory.newAlpha(cfg); InputProgram in = alpha.readProgramString(program); return alpha.solve(in).collect(Collectors.toSet()); } public static Set collectRegressionTestAnswerSets(InputProgram program, SystemConfig cfg) { - return new AlphaFactory().newAlpha(cfg) + return AlphaFactory.newAlpha(cfg) .solve(program) .collect(Collectors.toSet()); } private static Set solveForConfig(String programString, SystemConfig cfg) { - Alpha alpha = new AlphaFactory().newAlpha(cfg); + Alpha alpha = AlphaFactory.newAlpha(cfg); InputProgram program = alpha.readProgramString(programString); return alpha.solve(program).collect(Collectors.toSet()); } From aad55207d56caf48ecf5813f545f3af8dc08f303 Mon Sep 17 00:00:00 2001 From: Michael Langowski Date: Tue, 23 Jul 2024 11:01:01 +0200 Subject: [PATCH 96/96] Fix tests after merging changes from master --- .../commons/programs/rules/AbstractRule.java | 14 +- .../commons/programs/rules/BasicRule.java | 5 +- .../programs/rules/NormalRuleImpl.java | 5 +- .../alpha/commons/programs/rules/Rules.java | 15 +- .../programs/rules/heads/ActionHeadImpl.java | 92 +++--- .../commons/programs/rules/heads/Heads.java | 6 +- .../terms/AbstractActionResultTerm.java | 24 +- .../programs/terms/ActionErrorTerm.java | 22 +- .../programs/terms/ActionSuccessTerm.java | 24 +- .../atoms/BasicAtomImplTest.java | 25 +- .../atoms/ExternalAtomImplTest.java | 33 +-- ...LiteralBindingNonBindingVariablesTest.java | 68 ++--- .../commons/programs/terms/TermsTest.java | 2 +- .../alpha/core/parser/ParseTreeVisitor.java | 8 +- .../core/programs/rules/InternalRule.java | 2 +- .../IntervalTermToIntervalAtom.java | 1 + .../transformation/PredicateInternalizer.java | 2 - .../VariableEqualityRemoval.java | 12 +- .../encoders/AggregateEncoders.java | 1 - .../aggregates/encoders/CountEncoder.java | 6 +- .../aggregates/encoders/MinMaxEncoder.java | 13 +- .../StringtemplateBasedAggregateEncoder.java | 1 - .../aggregates/encoders/SumEncoder.java | 8 +- .../kr/alpha/core/common/ProgramTest.java | 37 +-- .../GrounderMockWithBasicProgram.java | 51 ++-- .../core/grounder/GrounderMockWithChoice.java | 60 ++-- .../core/grounder/NaiveGrounderTest.java | 41 +-- .../core/grounder/NoGoodGeneratorTest.java | 17 +- .../alpha/core/parser/AspCore2ParserTest.java | 11 - .../alpha/core/parser/EvologParserTest.java | 14 - .../alpha/core/programs/atoms/AtomsTest.java | 26 +- .../core/programs/atoms}/RuleAtomTest.java | 11 +- .../ProgramTransformationTest.java | 2 +- .../StratifiedEvaluationRegressionTest.java | 262 ------------------ .../AggregateRewritingRuleAnalysisTest.java | 2 +- .../core/rules/RuleGroundingInfoTest.java | 9 +- .../alpha/core/solver/AtomCounterTests.java | 2 +- .../AlphaHeuristicTestAssumptions.java | 6 +- .../ac/tuwien/kr/alpha/test}/RuleParser.java | 2 +- .../kr/alpha/api/impl/AlphaFactory.java | 2 +- .../tuwien/kr/alpha/api/impl/AlphaImpl.java | 34 ++- .../at/ac/tuwien/kr/alpha/ActionsTest.java | 7 +- .../alpha/AggregateLiteralSplittingTest.java | 16 +- .../AggregateOperatorNormalizationTest.java | 14 +- .../alpha/AggregateRewritingContextTest.java | 22 +- .../kr/alpha/AggregateRewritingTest.java | 34 +-- .../alpha/ArithmeticTermsRewritingTest.java | 25 +- .../FixedInterpretationLiteralsTest.java | 25 +- .../ac/tuwien/kr/alpha/RuleToStringTest.java | 16 +- .../kr/alpha/StratifiedEvaluationTest.java | 49 ++-- .../kr/alpha/api/impl/AlphaImplTest.java | 3 +- .../kr/alpha/regressiontests/SolverTests.java | 18 +- .../StratifiedEvaluationRegressionTest.java | 2 +- .../util/RegressionTestUtils.java | 23 +- .../test/util/MockedActionsAlphaFactory.java | 2 + 55 files changed, 427 insertions(+), 807 deletions(-) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/BasicAtomImplTest.java (85%) rename alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/{ => programs}/atoms/ExternalAtomImplTest.java (82%) rename {alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms => alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals}/LiteralBindingNonBindingVariablesTest.java (82%) delete mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java delete mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java rename {alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals => alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms}/RuleAtomTest.java (97%) delete mode 100644 alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java rename {alpha-solver/src/test/java/at/ac/tuwien/kr/alpha => alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test}/RuleParser.java (94%) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java index 5b8e4454e..c243d840b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java @@ -1,17 +1,15 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Objects; -import java.util.Set; - -import org.apache.commons.collections4.SetUtils; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.apache.commons.collections4.SetUtils; + +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.Objects; +import java.util.Set; /** * An abstract representation of a rule with a specific type of @{link Head} (type parameter H) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java index 13b991506..77aac0ea3 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java @@ -27,12 +27,11 @@ */ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.List; -import java.util.Set; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import java.util.Set; + /** * Represents a non-ground rule or a constraint. A {@link BasicRule} has a general {@link Head}, meaning both choice heads and disjunctive * heads are permissible. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java index 80225ef71..acd5ee0d5 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java @@ -1,12 +1,11 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.List; -import java.util.Set; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import java.util.Set; + /** * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. * Currently, any constructs such as aggregates, intervals, etc. in the rule body are allowed. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index f0456caba..9a19b54bc 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,16 +1,17 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.*; - import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.util.Util; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.Set; + public final class Rules { private Rules() { @@ -22,7 +23,7 @@ public static Rule newRule(Head head, Set body) { } public static Rule newRule(Head head, Literal... body) { - Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new BasicRule(head, bodyLst); } @@ -31,7 +32,7 @@ public static NormalRule newNormalRule(NormalHead head, Set body) { } public static NormalRule newNormalRule(NormalHead head, Literal... body) { - Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new NormalRuleImpl(head, bodyLst); } @@ -41,9 +42,9 @@ public static NormalRule toNormalRule(Rule rule) { if (!(rule.getHead() instanceof NormalHead)) { throw Util.oops("Trying to construct a NormalRule from rule with non-normal head! Head type is: " + rule.getHead().getClass().getSimpleName()); } - headAtom = ((NormalHead) rule.getHead()).getAtom(); + } - return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new LinkedHashSet<>(rule.getBody())); + return newNormalRule(rule.isConstraint() ? null : (NormalHead) rule.getHead(), new LinkedHashSet<>(rule.getBody())); } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java index 46a598442..4d41d044a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java @@ -13,51 +13,51 @@ class ActionHeadImpl implements ActionHead { - private final BasicAtom atom; - private final String actionName; - private final List actionInputTerms; - private final VariableTerm actionOutputTerm; - - ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { - this.atom = atom; - this.actionName = actionName; - this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); - this.actionOutputTerm = actionOutputTerm; - } - - @Override - public BasicAtom getAtom() { - return atom; - } - - @Override - public boolean isGround() { - // TODO: an action head is conceptually a basic one with an (interpreted) function term - return false; - } - - @Override - public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { - return instantiator.instantiate(this, substitution); - } - - @Override - public String getActionName() { - return actionName; - } - - @Override - public List getActionInputTerms() { - return actionInputTerms; - } - - @Override - public VariableTerm getActionOutputTerm() { - return actionOutputTerm; - } - - public String toString() { - return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; - } + private final BasicAtom atom; + private final String actionName; + private final List actionInputTerms; + private final VariableTerm actionOutputTerm; + + ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { + this.atom = atom; + this.actionName = actionName; + this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); + this.actionOutputTerm = actionOutputTerm; + } + + @Override + public BasicAtom getAtom() { + return atom; + } + + @Override + public boolean isGround() { + // TODO: an action head is conceptually a basic one with an (interpreted) function term + return false; + } + + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + + @Override + public String getActionName() { + return actionName; + } + + @Override + public List getActionInputTerms() { + return actionInputTerms; + } + + @Override + public VariableTerm getActionOutputTerm() { + return actionOutputTerm; + } + + public String toString() { + return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java index 3ebf81b63..d2d271258 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java @@ -1,18 +1,18 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; -import java.util.List; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; +import java.util.List; + public final class Heads { private Heads() { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java index 9a94e942d..1eacea528 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java @@ -7,20 +7,20 @@ abstract class AbstractActionResultTerm extends FunctionTermImpl implements ActionResultTerm { - AbstractActionResultTerm(String symbol, T value) { - super(symbol, Collections.singletonList(value)); - } + AbstractActionResultTerm(String symbol, T value) { + super(symbol, Collections.singletonList(value)); + } - public abstract boolean isSuccess(); + public abstract boolean isSuccess(); - public boolean isError() { - return !isSuccess(); - } + public boolean isError() { + return !isSuccess(); + } - // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. - @SuppressWarnings("unchecked") - public T getValue() { - return (T) getTerms().get(0); - } + // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. + @SuppressWarnings("unchecked") + public T getValue() { + return (T) getTerms().get(0); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java index 683b640c1..40815fe80 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java @@ -6,19 +6,19 @@ class ActionErrorTerm extends AbstractActionResultTerm> { - private static final Interner INTERNER = new Interner<>(); + private static final Interner INTERNER = new Interner<>(); - ActionErrorTerm(ConstantTerm value) { - super(ActionResultTerm.ERROR_SYMBOL, value); - } + ActionErrorTerm(ConstantTerm value) { + super(ActionResultTerm.ERROR_SYMBOL, value); + } - public static ActionErrorTerm getInstance(ConstantTerm term) { - return INTERNER.intern(new ActionErrorTerm(term)); - } + public static ActionErrorTerm getInstance(ConstantTerm term) { + return INTERNER.intern(new ActionErrorTerm(term)); + } - @Override - public boolean isSuccess() { - return false; - } + @Override + public boolean isSuccess() { + return false; + } } \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java index 2c4d7ddfd..c5a2fde14 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java @@ -6,20 +6,20 @@ class ActionSuccessTerm extends AbstractActionResultTerm { - private static final Interner> INTERNER = new Interner<>(); + private static final Interner> INTERNER = new Interner<>(); - ActionSuccessTerm(T value) { - super(ActionResultTerm.SUCCESS_SYMBOL, value); - } + ActionSuccessTerm(T value) { + super(ActionResultTerm.SUCCESS_SYMBOL, value); + } - @SuppressWarnings("unchecked") - public static ActionSuccessTerm getInstance(T term) { - return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); - } + @SuppressWarnings("unchecked") + public static ActionSuccessTerm getInstance(T term) { + return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); + } - @Override - public boolean isSuccess() { - return true; - } + @Override + public boolean isSuccess() { + return true; + } } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java similarity index 85% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java index 275aa413e..a500b850a 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java @@ -1,14 +1,11 @@ -package at.ac.tuwien.kr.alpha.commons.atoms; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; /** * Test for basic functionality of various implementations of {@link Atom}. @@ -56,12 +53,12 @@ public void testAreBasicAtomsEqual() { Terms.newFunctionTerm("r", Terms.newConstant("bla"), Terms.newVariable("BLUBB"))); assertEquals(a7, a8); - assertFalse(a1.equals(a3)); - assertFalse(a3.equals(a1)); - assertFalse(a1.equals(a5)); - assertFalse(a5.equals(a1)); - assertFalse(a1.equals(a7)); - assertFalse(a7.equals(a1)); + assertNotEquals(a1, a3); + assertNotEquals(a3, a1); + assertNotEquals(a1, a5); + assertNotEquals(a5, a1); + assertNotEquals(a1, a7); + assertNotEquals(a7, a1); } } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java similarity index 82% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java index d762709b5..9365625f6 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java @@ -1,27 +1,18 @@ -package at.ac.tuwien.kr.alpha.commons.atoms; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; public class ExternalAtomImplTest { @@ -83,9 +74,9 @@ public void testAreExternalAtomsEqual() { assertEquals(ext1, ext2); assertEquals(ext2, ext1); - assertFalse(ext1.equals(null)); - assertFalse(ext1.equals("bla")); - assertTrue(ext1.hashCode() == ext2.hashCode()); + assertNotEquals(null, ext1); + assertNotEquals("bla", ext1); + assertEquals(ext1.hashCode(), ext2.hashCode()); } @Test diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java similarity index 82% rename from alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java index 388cfff0b..8bd512135 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java @@ -23,39 +23,25 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -<<<<<<<< HEAD:alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/LiteralBindingNonBindingVariablesTest.java -package at.ac.tuwien.kr.alpha.commons.literals; -======== -package at.ac.tuwien.kr.alpha.core.programs.atoms; ->>>>>>>> master:alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; +package at.ac.tuwien.kr.alpha.commons.programs.literals; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -<<<<<<<< HEAD:alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/LiteralBindingNonBindingVariablesTest.java -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -======== -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; ->>>>>>>> master:alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java +import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.externals.IntPredicateInterpretation; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import java.util.*; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.*; /** * Tests the behaviour of {@link Literal#getBindingVariables()} and {@link Literal#getNonBindingVariables()} @@ -68,7 +54,7 @@ public class LiteralBindingNonBindingVariablesTest { public void testPositiveBasicLiteral() { // literal := q(X, Y) Literal literal = Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("q", 2), Terms.newVariable("X"), Terms.newVariable("Y")), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X", "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -77,7 +63,7 @@ public void testPositiveBasicLiteral() { public void testNegativeBasicLiteral() { // literal := not r(X, Y) Literal literal = Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("r", 2), Terms.newVariable("X"), Terms.newVariable("Y")), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -86,7 +72,7 @@ public void testNegativeBasicLiteral() { public void testPositiveComparisonLiteral_EQ_LeftAssigning() { // literal := Y = 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.EQ), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -95,7 +81,7 @@ public void testPositiveComparisonLiteral_EQ_LeftAssigning() { public void testNegativeComparisonLiteral_EQ_LeftAssigning() { // literal := not Y = 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -104,7 +90,7 @@ public void testNegativeComparisonLiteral_EQ_LeftAssigning() { public void testPositiveComparisonLiteral_EQ_RightAssigning() { // literal := 5 = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.EQ), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -113,7 +99,7 @@ public void testPositiveComparisonLiteral_EQ_RightAssigning() { public void testNegativeComparisonLiteral_EQ_RightAssigning() { // literal := 5 = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -122,7 +108,7 @@ public void testNegativeComparisonLiteral_EQ_RightAssigning() { public void testNegativeComparisonLiteral_EQ_Bidirectional() { // literal := not X = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -131,7 +117,7 @@ public void testNegativeComparisonLiteral_EQ_Bidirectional() { public void testPositiveComparisonLiteral_NEQ_LeftAssigning() { // literal := Y != 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -140,7 +126,7 @@ public void testPositiveComparisonLiteral_NEQ_LeftAssigning() { public void testNegativeComparisonLiteral_NEQ_LeftAssigning() { // literal := not Y != 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -149,7 +135,7 @@ public void testNegativeComparisonLiteral_NEQ_LeftAssigning() { public void testPositiveComparisonLiteral_NEQ_RightAssigning() { // literal := 5 != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -158,7 +144,7 @@ public void testPositiveComparisonLiteral_NEQ_RightAssigning() { public void testNegativeComparisonLiteral_NEQ_RightAssigning() { // literal := not 5 != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -167,7 +153,7 @@ public void testNegativeComparisonLiteral_NEQ_RightAssigning() { public void testPositiveComparisonLiteral_NEQ_Bidirectional() { // literal := X != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -177,7 +163,7 @@ public void testPositiveComparisonLiteral_NEQ_Bidirectional() { public void testNegativeComparisonLiteral_NEQ_Bidirectional() { // literal := not X != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X", "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -190,7 +176,7 @@ public void testPositiveExternalLiteral() { extInput.add(Terms.newVariable("Y")); extOutput.add(Terms.newVariable("X")); Literal literal = Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), new IntPredicateInterpretation(i -> i > 0), extInput, extOutput), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X"); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -203,7 +189,7 @@ public void testNegativeExternalLiteral() { extInput.add(Terms.newVariable("Y")); extOutput.add(Terms.newVariable("X")); Literal literal = Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), new IntPredicateInterpretation(i -> i > 0), extInput, extOutput), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java index b6700d2e2..50e5afb51 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java @@ -4,10 +4,10 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; public class TermsTest { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 610df11ad..6bdb979cf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -222,11 +222,15 @@ public Head visitDisjunction(ASPCore2Parser.DisjunctionContext ctx) { @Override public Head visitHead(ASPCore2Parser.HeadContext ctx) { - // head : disjunction | choice; + // head : disjunction | choice | action; if (ctx.choice() != null) { return visitChoice(ctx.choice()); + } else if (ctx.action() != null) { + return visitAction(ctx.action()); + } else if (ctx.disjunction() != null) { + return visitDisjunction(ctx.disjunction()); } - return visitDisjunction(ctx.disjunction()); + throw notSupported(ctx); } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index 1bc31f104..c6bbf7239 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -103,7 +103,7 @@ public static void resetIdGenerator() { } public static CompiledRule fromNormalRule(Rule rule) { - return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new LinkedHashSet<>(rule.getBody())); + return new InternalRule(rule.isConstraint() ? null : rule.getHead(), new LinkedHashSet<>(rule.getBody())); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 9b1c69143..ef73eec08 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -75,6 +75,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { } // Note that this cast is safe: NormalHead can only have a BasicAtom, so literalizing and getting back the Atom destroys type information, // but should never yield anything other than a BasicAtom + // TODO handle action headS! NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead((BasicAtom) rewriteLiteral(rule.getHead().getAtom().toLiteral(), intervalReplacements).getAtom()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index d33962805..5095da814 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -16,9 +16,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; -import java.util.ArrayList; import java.util.LinkedHashSet; -import java.util.List; import java.util.Set; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index a08aac2e2..1ca5eb985 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -34,6 +34,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.DisjunctiveHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; @@ -108,7 +109,16 @@ private Rule findAndReplaceVariableEquality(Rule rule) { if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } - NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead)rule.getHead()).getAtom()); + // TODO can this be done nicer? + NormalHead rewrittenHead = null; + if (!rule.isConstraint()) { + if (rule.getHead() instanceof ActionHead) { + ActionHead actHead = (ActionHead) rule.getHead(); + rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getActionName(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); + } else { + rewrittenHead = Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + } + } // Use substitution for actual replacement. Unifier replacementSubstitution = new Unifier(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java index 686fed1f6..a22ecb65e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java @@ -1,6 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; public final class AggregateEncoders { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java index 44a10a5a3..dceca1dcf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java @@ -1,13 +1,11 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import org.stringtemplate.v4.ST; -import org.stringtemplate.v4.STGroup; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.stringtemplate.v4.ST; +import org.stringtemplate.v4.STGroup; public final class CountEncoder extends StringtemplateBasedAggregateEncoder { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 242fc7719..0f8b5d9da 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -1,13 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -import org.apache.commons.collections4.SetUtils; -import org.stringtemplate.v4.ST; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; @@ -35,6 +27,11 @@ import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.collections4.SetUtils; +import org.stringtemplate.v4.ST; + +import java.util.LinkedHashSet; +import java.util.Set; public class MinMaxEncoder extends AbstractAggregateEncoder { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index a7eeb9fab..94fa889c8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -20,7 +20,6 @@ import org.apache.commons.collections4.ListUtils; import org.stringtemplate.v4.ST; -import java.util.ArrayList; import java.util.Collections; import java.util.LinkedHashSet; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java index 0dc4a0358..c184d2dce 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java @@ -1,21 +1,19 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import org.stringtemplate.v4.ST; -import org.stringtemplate.v4.STGroup; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.stringtemplate.v4.ST; +import org.stringtemplate.v4.STGroup; /** * Aggregate encoder handling sum aggregates. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java index b102d6fd3..71b6aef05 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java @@ -25,45 +25,24 @@ */ package at.ac.tuwien.kr.alpha.core.common; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; -import java.util.List; - +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; +import static org.junit.jupiter.api.Assertions.assertEquals; public class ProgramTest { @Test public void testToString() { - InputProgram program; - // rule := q(X) :- p(X). - List body = new ArrayList<>(); - body.add(Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newVariable("X")), true)); - Rule rule = Rules.newRule( - Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newVariable("X")), - Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newVariable("X")).toLiteral()); - List facts = new ArrayList<>(); - facts.add(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("a"))); - facts.add(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("b"))); - // program := p(a). p(b). q(X) :- p(X). - program = InputProgramImpl.builder().addFacts(facts).addRule(rule).build(); + InputProgram parsedProgram = new ProgramParserImpl().parse( + "p(a)." + System.lineSeparator() + + "q(X) :- p(X)." + System.lineSeparator() + + "p(b)."); assertEquals( "p(a)." + System.lineSeparator() + "p(b)." + System.lineSeparator() + "q(X) :- p(X)." + System.lineSeparator(), - program.toString()); + parsedProgram.toString()); } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java index fe2cb6f8c..a298cb6eb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2016-2019, the Alpha Team. * All rights reserved. - * + * * Additional changes made by Siemens. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + * * 1) Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * + * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -44,6 +44,9 @@ import java.util.TreeSet; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; @@ -51,43 +54,38 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * Represents a small ASP program {@code { c :- a, b. a. b. }}. * * Copyright (c) 2016, the Alpha Team. */ -public class DummyGrounder implements Grounder { +public class GrounderMockWithBasicProgram implements Grounder { public static final Set EXPECTED = new HashSet<>(singletonList(new AnswerSetBuilder() - .predicate("a") - .predicate("b") - .predicate("c") - .build() + .predicate("a") + .predicate("b") + .predicate("c") + .build() )); private static final int FACT_A = 11; // { -a } private static final int FACT_B = 12; // { -b } private static final int RULE_B = 13; // { -_br1, a, b } private static final int RULE_H = 14; // { -c, _br1 } private static final Map NOGOODS = Stream.of( - entry(FACT_A, headFirst(fromOldLiterals(-1))), - entry(FACT_B, headFirst(fromOldLiterals(-2))), - entry(RULE_B, headFirst(fromOldLiterals(-3, 1, 2))), - entry(RULE_H, headFirst(fromOldLiterals(-4, 3))) + entry(FACT_A, headFirst(fromOldLiterals(-1))), + entry(FACT_B, headFirst(fromOldLiterals(-2))), + entry(RULE_B, headFirst(fromOldLiterals(-3, 1, 2))), + entry(RULE_H, headFirst(fromOldLiterals(-4, 3))) ).collect(entriesToMap()); private final AtomStore atomStore; private final java.util.function.Predicate filter; @@ -95,15 +93,15 @@ public class DummyGrounder implements Grounder { private static Atom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("a", 0)); private static Atom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("b", 0)); private static BasicAtom atomCC = Atoms.newBasicAtom(Predicates.getPredicate("c", 0)); - private static Rule ruleABC = Rules.newRule(Heads.newNormalHead(atomCC), Arrays.asList(atomAA.toLiteral(), atomBB.toLiteral())); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleABC)), new BasicSubstitution()); + private static CompiledRule ruleABC = CompiledRules.newCompiledRule(Heads.newNormalHead(atomCC), atomAA.toLiteral(), atomBB.toLiteral()); + private static Atom rule1 = new RuleAtom(ruleABC, new BasicSubstitution()); private Set returnedNogoods = new HashSet<>(); - public DummyGrounder(AtomStore atomStore) { + public GrounderMockWithBasicProgram(AtomStore atomStore) { this(atomStore, p -> true); } - public DummyGrounder(AtomStore atomStore, java.util.function.Predicate filter) { + public GrounderMockWithBasicProgram(AtomStore atomStore, java.util.function.Predicate filter) { this.atomStore = atomStore; this.filter = filter; Arrays.asList(atomAA, atomBB, rule1, atomCC).forEach(atomStore::putIfAbsent); @@ -172,7 +170,7 @@ public Map getNoGoods(Assignment assignment) { public Pair, Map> getChoiceAtoms() { return new ImmutablePair<>(new HashMap<>(), new HashMap<>()); } - + @Override public Map> getHeadsToBodies() { return Collections.emptyMap(); @@ -191,4 +189,5 @@ private void addNoGoodIfNotAlreadyReturned(Map integerNoGoodMap returnedNogoods.add(idNoGood); } } -} + +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java index 530d54944..d2d22c212 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2016-2019, the Alpha Team. * All rights reserved. - * + * * Additional changes made by Siemens. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + * * 1) Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * + * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -32,6 +32,7 @@ import static at.ac.tuwien.kr.alpha.core.common.NoGood.headFirst; import static at.ac.tuwien.kr.alpha.core.common.NoGoodTest.fromOldLiterals; import static java.util.Arrays.asList; +import static java.util.Collections.singleton; import java.util.Arrays; import java.util.Collections; @@ -43,6 +44,9 @@ import java.util.TreeSet; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; @@ -50,34 +54,30 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** - * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. + * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. */ -public class ChoiceGrounder implements Grounder { +public class GrounderMockWithChoice implements Grounder { public static final Set EXPECTED = new HashSet<>(asList( new AnswerSetBuilder() .predicate("aa") .build(), new AnswerSetBuilder() .predicate("bb") - .build())); + .build() + )); private static final int ATOM_AA = 1; private static final int ATOM_BB = 2; @@ -93,7 +93,7 @@ public class ChoiceGrounder implements Grounder { private static final int BRULE_BB = 14; // { -_br2, -aa } private static final int CHOICE_EN_BR1 = 15; // { -_en_br1 } private static final int CHOICE_EN_BR2 = 16; // { -_en_br2 } - private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} + private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} private static final int CHOICE_DIS_BR2 = 18; // { -dis_br2, aa } private static final Map NOGOODS = Stream.of( entry(RULE_AA, headFirst(fromOldLiterals(-ATOM_AA, ATOM_BR1))), @@ -103,21 +103,22 @@ public class ChoiceGrounder implements Grounder { entry(CHOICE_EN_BR1, headFirst(fromOldLiterals(-ATOM_EN_BR1))), entry(CHOICE_EN_BR2, headFirst(fromOldLiterals(-ATOM_EN_BR2))), entry(CHOICE_DIS_BR1, headFirst(fromOldLiterals(-ATOM_DIS_BR1, ATOM_BB))), - entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA)))).collect(entriesToMap()); + entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA))) + ).collect(entriesToMap()); private static final Map CHOICE_ENABLE = Stream.of( entry(ATOM_BR1, ATOM_EN_BR1), - entry(ATOM_BR2, ATOM_EN_BR2)).collect(entriesToMap()); + entry(ATOM_BR2, ATOM_EN_BR2) + ).collect(entriesToMap()); private static final Map CHOICE_DISABLE = Stream.of( entry(ATOM_BR1, ATOM_DIS_BR1), - entry(ATOM_BR2, ATOM_DIS_BR2)).collect(entriesToMap()); + entry(ATOM_BR2, ATOM_DIS_BR2) + ).collect(entriesToMap()); private static BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); private static BasicAtom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)); - private static Rule ruleAA = Rules.newRule(Heads.newNormalHead(atomAA), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); - private static Rule ruleBB = Rules.newRule(Heads.newNormalHead(atomBB), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false))); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleAA)), new BasicSubstitution()); - private static Atom rule2 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleBB)), new BasicSubstitution()); + private static CompiledRule ruleAA = CompiledRules.newCompiledRule(Heads.newNormalHead(atomAA), Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false)); + private static CompiledRule ruleBB = CompiledRules.newCompiledRule(Heads.newNormalHead(atomBB), Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false)); + private static Atom rule1 = new RuleAtom(ruleAA, new BasicSubstitution()); + private static Atom rule2 = new RuleAtom(ruleBB, new BasicSubstitution()); private static Atom atomEnBR1 = ChoiceAtom.on(1); private static Atom atomEnBR2 = ChoiceAtom.on(2); private static Atom atomDisBR1 = ChoiceAtom.off(3); @@ -127,11 +128,11 @@ public class ChoiceGrounder implements Grounder { private final java.util.function.Predicate filter; - public ChoiceGrounder(AtomStore atomStore) { + public GrounderMockWithChoice(AtomStore atomStore) { this(atomStore, p -> true); } - public ChoiceGrounder(AtomStore atomStore, java.util.function.Predicate filter) { + public GrounderMockWithChoice(AtomStore atomStore, java.util.function.Predicate filter) { this.atomStore = atomStore; this.filter = filter; Arrays.asList(atomAA, atomBB, rule1, rule2, atomEnBR1, atomEnBR2, atomDisBR1, atomDisBR2).forEach(atomStore::putIfAbsent); @@ -155,11 +156,11 @@ public AnswerSet assignmentToAnswerSet(Iterable trueAtoms) { Map> predicateInstances = new HashMap<>(); for (Predicate trueAtomPredicate : trueAtomPredicates) { BasicAtom basicAtom = Atoms.newBasicAtom(trueAtomPredicate); - predicateInstances.put(trueAtomPredicate, new TreeSet<>(Collections.singleton(basicAtom))); + predicateInstances.put(trueAtomPredicate, new TreeSet<>(singleton(basicAtom))); } // Note: This grounder only deals with 0-ary predicates, i.e., every atom is a predicate and there is - // only one predicate instance representing 0 terms. + // only one predicate instance representing 0 terms. return AnswerSets.newAnswerSet(trueAtomPredicates, predicateInstances); } @@ -209,4 +210,5 @@ public int register(NoGood noGood) { } return solverDerivedNoGoods.get(noGood); } -} + +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java index cdee89727..74ce484f3 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java @@ -25,7 +25,6 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.atom; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; @@ -36,6 +35,10 @@ import java.util.List; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -104,10 +107,10 @@ public void groundRuleAlreadyGround() { + "b :- not a. " + "c :- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - CompiledProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + CompiledProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litCNeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("c")), false); int litB = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b"))); @@ -126,10 +129,10 @@ public void groundRuleWithLongerBodyAlreadyGround() { + "c :- b. " + "d :- b, c. "); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - InternalProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + InternalProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litANeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("a")), false); int litBNeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b")), false); @@ -151,10 +154,10 @@ public void groundConstraintAlreadyGround() { + "b :- not a. " + ":- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - InternalProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + InternalProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litB = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b"))); assertTrue(noGoods.containsValue(NoGood.fromConstraint(Collections.singletonList(litB), Collections.emptyList()))); @@ -189,7 +192,7 @@ public void noDeadEndWithPermissiveGrounderHeuristicForQ1() { } /** - * Tests the method {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} on a + * Tests the method {@link NaiveGrounder#getGroundInstantiations)} on a * predefined program: * * p1(1). q1(1).
@@ -218,8 +221,7 @@ private void testDeadEnd(String predicateNameOfStartingLiteral, RuleGroundingOrd PROGRAM_PARSER.parse(aspStr))); AtomStore atomStore = new AtomStoreImpl(); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", program, atomStore, p -> true, - GrounderHeuristicsConfiguration.permissive(), true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(GrounderHeuristicsConfiguration.permissive(), true).createGrounder(program, atomStore, p -> true); CompiledRule nonGroundRule = grounder.getNonGroundRule(0); String strLiteral = "p1".equals(predicateNameOfStartingLiteral) ? "p1(X)" : "p1(Y)"; @@ -270,7 +272,7 @@ public void testGroundingOfRuleNotSwitchedOffByFalseNegativeBody() { } /** - * Tests if {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} + * Tests if {@link NaiveGrounder#getGroundInstantiations(CompiledRule, RuleGroundingOrder, Substitution, Assignment)} * produces ground instantiations for the rule with ID {@code ruleID} in {@code program} when {@code startingLiteral} * unified with the numeric instance {@code startingInstance} is used as starting literal and {@code b(1)} is assigned * {@code bTruth}. @@ -281,10 +283,9 @@ private void testIfGrounderGroundsRule(InputProgram program, int ruleID, Literal CompiledProgram internalPrg = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(program)); AtomStore atomStore = new AtomStoreImpl(); TrailAssignment currentAssignment = new TrailAssignment(atomStore); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", internalPrg, atomStore, p -> true, - GrounderHeuristicsConfiguration.permissive(), true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(GrounderHeuristicsConfiguration.permissive(), true).createGrounder(internalPrg, atomStore, p -> true); - int b = atomStore.putIfAbsent(atom("b", 1)); + int b = atomStore.putIfAbsent(Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newConstant(1))); currentAssignment.growForMaxAtomId(); currentAssignment.assign(b, bTruth); @@ -369,7 +370,7 @@ private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int } /** - * Tests if {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} + * Tests if {@link NaiveGrounder#getGroundInstantiations(CompiledRule, RuleGroundingOrder, Substitution, Assignment)} * produces ground instantiations for the rule with ID {@code ruleID} in {@code program} when {@code startingLiteral} * unified with the numeric instance {@code startingInstance} is used as starting literal and the following * additional conditions are established: @@ -392,7 +393,7 @@ private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int AtomStore atomStore = new AtomStoreImpl(); TrailAssignment currentAssignment = new TrailAssignment(atomStore); GrounderHeuristicsConfiguration heuristicConfiguration = GrounderHeuristicsConfiguration.getInstance(tolerance, tolerance); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", internalPrg, atomStore, p -> true, heuristicConfiguration, true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(heuristicConfiguration, true).createGrounder(internalPrg, atomStore, p -> true); int[] bAtomIDs = new int[truthsOfB.length]; for (int i = 0; i < truthsOfB.length; i++) { @@ -457,4 +458,12 @@ private void assertExistsNoGoodContaining(Collection noGoods, int litera fail("No NoGood exists that contains literal " + literal); } + private static Atom atom(String predicateName, int... termInts) { + Term[] terms = new Term[termInts.length]; + for (int i = 0; i < termInts.length; i++) { + terms[i] = Terms.newConstant(termInts[i]); + } + return Atoms.newBasicAtom(Predicates.getPredicate(predicateName, terms.length), terms); + } + } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java index ef42a9eb7..eb0a06392 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java @@ -25,12 +25,7 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.List; - -import org.junit.jupiter.api.Test; - +import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -47,8 +42,12 @@ import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; /** * Tests {@link NoGoodGenerator} @@ -66,7 +65,7 @@ public class NoGoodGeneratorTest { private static final VariableTerm Y = Terms.newVariable("Y"); /** - * Calls {@link NoGoodGenerator#collectNegLiterals(InternalRule, Substitution)}, which puts the atom occurring + * Calls {@link NoGoodGenerator#collectNegLiterals(CompiledRule, Substitution)}, which puts the atom occurring * negatively in a rule into the atom store. It is then checked whether the atom in the atom store is positive. */ @Test @@ -79,7 +78,7 @@ public void collectNeg_ContainsOnlyPositiveLiterals() { CompiledRule rule = program.getRules().get(1); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", program, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(program, atomStore); NoGoodGenerator noGoodGenerator = ((NaiveGrounder) grounder).noGoodGenerator; Substitution substitution = new BasicSubstitution(); substitution.put(X, A); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java deleted file mode 100644 index 7b96f4f92..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser; - -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; - -public class AspCore2ParserTest extends ParserTest { - - protected AspCore2ParserTest() { - super(new InputProgramParser()); - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java deleted file mode 100644 index 69e7eb0b7..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java +++ /dev/null @@ -1,14 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser; - -import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; - -public class EvologParserTest extends ParserTest { - - protected EvologParserTest() { - super(new EvologProgramParser(new DefaultActionImplementationProvider())); - } - - - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java index d202e579c..ac961bebe 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java @@ -1,9 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.atoms; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -22,9 +18,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import static org.junit.jupiter.api.Assertions.*; + /** * Test for basic functionality of various implementations of {@link Atom}. * @@ -91,12 +89,12 @@ public void testAreBasicAtomsEqual() { Atom a8 = p4.getFacts().get(1); assertEquals(a7, a8); - assertFalse(a1.equals(a3)); - assertFalse(a3.equals(a1)); - assertFalse(a1.equals(a5)); - assertFalse(a5.equals(a1)); - assertFalse(a1.equals(a7)); - assertFalse(a7.equals(a1)); + assertNotEquals(a1, a3); + assertNotEquals(a3, a1); + assertNotEquals(a1, a5); + assertNotEquals(a5, a1); + assertNotEquals(a1, a7); + assertNotEquals(a7, a1); } @Test @@ -122,9 +120,9 @@ public void testAreExternalAtomsEqual() { assertEquals(ext1, ext2); assertEquals(ext2, ext1); - assertFalse(ext1.equals(null)); - assertFalse(ext1.equals("bla")); - assertTrue(ext1.hashCode() == ext2.hashCode()); + assertNotEquals(null, ext1); + assertNotEquals("bla", ext1); + assertEquals(ext1.hashCode(), ext2.hashCode()); } @Test diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java similarity index 97% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java rename to alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java index 56e64c4ef..e89317207 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java @@ -1,7 +1,10 @@ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import static org.junit.jupiter.api.Assertions.assertEquals; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; @@ -18,17 +21,13 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Copyright (c) 2022, the Alpha Team. */ public class RuleAtomTest { - private static final ProgramParser PARSER = new ProgramParserImpl(); + private static final ProgramParser PARSER = new ProgramParserImpl(); private static final VariableTerm X = Terms.newVariable("X"); private static final VariableTerm Y = Terms.newVariable("Y"); private static final Predicate PREDICATE = Predicates.getPredicate("p", 1); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index 79ae8be23..345cc41bb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -16,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; public class ProgramTransformationTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java deleted file mode 100644 index 383cf8ac0..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java +++ /dev/null @@ -1,262 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.function.Consumer; - -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; -import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; - -public class StratifiedEvaluationRegressionTest { - - private static final Logger LOGGER = LoggerFactory.getLogger(StratifiedEvaluationRegressionTest.class); - - private static final String STRATIFIED_NEG_ASP = "base(X) :- req(X), not incomp(X).\n" - + "depend_base(X, Y) :- base(X), base(Y).\n" - + "dep_b_hlp(X) :- depend_base(X, _).\n" - + "fallback_base(X) :- base(X), not dep_b_hlp(X).\n" - + "depend_further(X) :- depend_base(_, X).\n" - + "depend_further(X) :- fallback_base(X)."; - - private static final String BASIC_TEST_ASP = "a. b:- a."; - private static final String BASIC_MULTI_INSTANCE_ASP = "p(a). p(b). q(X) :- p(X)."; - private static final String BASIC_NEGATION_ASP = "p(a). q(b). p(c). q(d). r(c). s(X, Y) :- p(X), q(Y), not r(X)."; - private static final String PART_STRATIFIED_ASP = "p(a). q(a). p(b). m(c). n(d).\n" + "r(X) :- p(X), q(X).\n" + "s(X, Y, Z) :- r(X), m(Y), n(Z).\n" - + "t(X, Y) :- p(X), q(X), p(Y), not q(Y).\n" + "either(X) :- t(X, _), not or(X).\n" + "or(X) :- t(X, _), not either(X)."; - private static final String POSITIVE_RECURSION_ASP = "num(0).\n" + "max_num(10).\n" + "num(S) :- num(N), S = N + 1, S <= M, max_num(M)."; - private static final String EMPTY_PROG_ASP = ""; - private static final String FACTS_ONLY_ASP = "a. b. c. p(a). q(b, c). r(c, c, a). s(b)."; - private static final String STRATIFIED_NO_FACTS_ASP = STRATIFIED_NEG_ASP; - private static final String STRATIFIED_W_FACTS_ASP = "req(a). req(b). incomp(b).\n" + STRATIFIED_NEG_ASP; - private static final String EQUALITY_ASP = "equal :- 1 = 1."; - private static final String EQUALITY_WITH_VAR_ASP = "a(1). a(2). a(3). b(X) :- a(X), X = 1. c(X) :- a(X), X = 2. d(X) :- X = 3, a(X)."; - - private static final ImmutablePair, Consumer>> BASIC_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasic, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasic); - private static final ImmutablePair, Consumer>> BASIC_MULTI_INSTANCE_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasicMultiInstance, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasicMultiInstance); - private static final ImmutablePair, Consumer>> BASIC_NEGATION_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasicNegation, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasicNegation); - private static final ImmutablePair, Consumer>> PART_STRATIFIED_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramPartStratified, StratifiedEvaluationRegressionTest::verifyAnswerSetsPartStratified); - private static final ImmutablePair, Consumer>> POSITIVE_RECURSIVE_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramPositiveRecursive, StratifiedEvaluationRegressionTest::verifyAnswerSetsPositiveRecursive); - private static final ImmutablePair, Consumer>> EMPTY_PROG_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEmptyProg, StratifiedEvaluationRegressionTest::verifyAnswerSetsEmptyProg); - private static final ImmutablePair, Consumer>> FACTS_ONLY_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramFactsOnly, StratifiedEvaluationRegressionTest::verifyAnswerSetsFactsOnly); - private static final ImmutablePair, Consumer>> STRATIFIED_NO_FACTS_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramStratNoFacts, StratifiedEvaluationRegressionTest::verifyAnswerSetsStratNoFacts); - private static final ImmutablePair, Consumer>> STRATIFIED_W_FACTS_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramStratWithFacts, StratifiedEvaluationRegressionTest::verifyAnswerSetsStratWithFacts); - private static final ImmutablePair, Consumer>> EQUALITY_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEquality, StratifiedEvaluationRegressionTest::verifyAnswerSetsEquality); - private static final ImmutablePair, Consumer>> EQUALITY_WITH_VAR_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEqualityWithVar, StratifiedEvaluationRegressionTest::verifyAnswerSetsEqualityWithVar); - - public static List params() { - List, Consumer>>>> testCases = new ArrayList<>(); - List paramList = new ArrayList<>(); - testCases.add(new ImmutablePair<>(BASIC_TEST_ASP, BASIC_VERIFIERS)); - testCases.add(new ImmutablePair<>(BASIC_MULTI_INSTANCE_ASP, BASIC_MULTI_INSTANCE_VERIFIERS)); - testCases.add(new ImmutablePair<>(BASIC_NEGATION_ASP, BASIC_NEGATION_VERIFIERS)); - testCases.add(new ImmutablePair<>(PART_STRATIFIED_ASP, PART_STRATIFIED_VERIFIERS)); - testCases.add(new ImmutablePair<>(POSITIVE_RECURSION_ASP, POSITIVE_RECURSIVE_VERIFIERS)); - testCases.add(new ImmutablePair<>(EMPTY_PROG_ASP, EMPTY_PROG_VERIFIERS)); - testCases.add(new ImmutablePair<>(FACTS_ONLY_ASP, FACTS_ONLY_VERIFIERS)); - testCases.add(new ImmutablePair<>(STRATIFIED_NO_FACTS_ASP, STRATIFIED_NO_FACTS_VERIFIERS)); - testCases.add(new ImmutablePair<>(STRATIFIED_W_FACTS_ASP, STRATIFIED_W_FACTS_VERIFIERS)); - testCases.add(new ImmutablePair<>(EQUALITY_ASP, EQUALITY_VERIFIERS)); - testCases.add(new ImmutablePair<>(EQUALITY_WITH_VAR_ASP, EQUALITY_WITH_VAR_VERIFIERS)); - - testCases.forEach((pair) -> paramList.add(Arguments.of(pair.left, pair.right.left, pair.right.right))); - return paramList; - } - - @ParameterizedTest - @MethodSource("at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluationRegressionTest#params") - public void runTest(String aspString, Consumer programVerifier, Consumer> resultVerifier) { - // Parse and pre-evaulate program - ProgramParser parser = new ProgramParserImpl(); - InputProgram prog = parser.parse(aspString); - AnalyzedProgram analyzed = AnalyzedProgram - .analyzeNormalProgram(new NormalizeProgramTransformation(SystemConfig.DEFAULT_AGGREGATE_REWRITING_CONFIG).apply(prog)); - CompiledProgram evaluated = new StratifiedEvaluation().apply(analyzed); - // Verify stratified evaluation result - programVerifier.accept(evaluated); - // Solve remaining program - AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", evaluated, atomStore, false); - Solver solver = SolverFactory.getInstance(new SystemConfig(), atomStore, grounder); - Set answerSets = solver.collectSet(); - resultVerifier.accept(answerSets); - } - - private static void verifyProgramBasic(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("a"), TestUtils.basicAtomWithSymbolicTerms("b")); - assertEquals(2, evaluated.getFacts().size()); - assertTrue(evaluated.getRules().size() == 0); - } - - private static void verifyAnswerSetsBasic(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a, b", answerSets); - } - - private static void verifyProgramBasicMultiInstance(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("q", "a"), TestUtils.basicAtomWithSymbolicTerms("q", "b")); - assertTrue(evaluated.getRules().size() == 0); - } - - private static void verifyAnswerSetsBasicMultiInstance(Set answerSets) { - TestUtils.assertAnswerSetsEqual("p(a), p(b), q(a), q(b)", answerSets); - } - - private static void verifyProgramBasicNegation(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("s", "a", "b"), - TestUtils.basicAtomWithSymbolicTerms("s", "a", "d")); - assertEquals(7, evaluated.getFacts().size()); - assertEquals(0, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsBasicNegation(Set answerSets) { - TestUtils.assertAnswerSetsEqual("p(a), q(b), p(c), q(d), r(c), s(a,b), s(a,d)", answerSets); - } - - private static void verifyProgramPartStratified(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("p", "a"), TestUtils.basicAtomWithSymbolicTerms("q", "a"), - TestUtils.basicAtomWithSymbolicTerms("p", "b"), - TestUtils.basicAtomWithSymbolicTerms("m", "c"), TestUtils.basicAtomWithSymbolicTerms("n", "d"), TestUtils.basicAtomWithSymbolicTerms("r", "a"), - TestUtils.basicAtomWithSymbolicTerms("s", "a", "c", "d"), - TestUtils.basicAtomWithSymbolicTerms("t", "a", "b")); - LOGGER.debug("part stratified evaluated prog is:\n{}", evaluated.toString()); - assertEquals(2, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsPartStratified(Set answerSets) { - TestUtils.assertAnswerSetsEqual(new String[] {"p(a), q(a), p(b), m(c), n(d), r(a), s(a,c,d), t(a,b), either(a)", - "p(a), q(a), p(b), m(c), n(d), r(a), s(a,c,d), t(a,b), or(a)" }, answerSets); - } - - private static void verifyProgramPositiveRecursive(CompiledProgram evaluated) { - Predicate num = Predicates.getPredicate("num", 1); - TestUtils.assertFactsContainedInProgram(evaluated, Atoms.newBasicAtom(Predicates.getPredicate("max_num", 1), Terms.newConstant(10)), - Atoms.newBasicAtom(num, Terms.newConstant(0)), - Atoms.newBasicAtom(num, Terms.newConstant(1)), Atoms.newBasicAtom(num, Terms.newConstant(2)), - Atoms.newBasicAtom(num, Terms.newConstant(3)), Atoms.newBasicAtom(num, Terms.newConstant(4)), - Atoms.newBasicAtom(num, Terms.newConstant(5)), Atoms.newBasicAtom(num, Terms.newConstant(6)), - Atoms.newBasicAtom(num, Terms.newConstant(7)), Atoms.newBasicAtom(num, Terms.newConstant(8)), - Atoms.newBasicAtom(num, Terms.newConstant(9)), Atoms.newBasicAtom(num, Terms.newConstant(10))); - LOGGER.debug("Recursive program evaluated is:\n{}", evaluated.toString()); - assertEquals(0, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsPositiveRecursive(Set answerSets) { - TestUtils.assertAnswerSetsEqual("max_num(10), num(0), num(1), num(2), num(3), num(4), num(5), num(6), num(7), num(8), num(9), num(10)", answerSets); - } - - private static void verifyProgramEmptyProg(CompiledProgram evaluated) { - assertTrue(evaluated.getRules().isEmpty()); - assertTrue(evaluated.getRulesById().isEmpty()); - assertTrue(evaluated.getPredicateDefiningRules().isEmpty()); - assertTrue(evaluated.getFacts().isEmpty()); - assertTrue(evaluated.getFactsByPredicate().isEmpty()); - } - - private static void verifyAnswerSetsEmptyProg(Set answerSets) { - assertEquals(1, answerSets.size()); - assertTrue(answerSets.iterator().next().isEmpty()); - } - - private static void verifyProgramFactsOnly(CompiledProgram evaluated) { - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("b"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("c"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("p", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("q", "b", "c"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("r", "c", "c", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("s", "b"))); - } - - private static void verifyAnswerSetsFactsOnly(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a, b, c, p(a), q(b,c), r(c,c,a), s(b)", answerSets); - } - - private static void verifyProgramStratNoFacts(CompiledProgram evaluated) { - assertTrue(evaluated.getFacts().isEmpty()); - } - - private static void verifyAnswerSetsStratNoFacts(Set answerSets) { - assertEquals(1, answerSets.size()); - assertTrue(answerSets.iterator().next().isEmpty()); - } - - private static void verifyProgramStratWithFacts(CompiledProgram evaluated) { - // rules should all be taken care of at this point - assertTrue(evaluated.getRules().isEmpty()); - assertTrue(evaluated.getRulesById().isEmpty()); - assertTrue(evaluated.getPredicateDefiningRules().isEmpty()); - - // facts should be the full answer set - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("req", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("req", "b"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("incomp", "b"))); - - // below facts from stratified evaluation - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("base", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("depend_base", "a", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("dep_b_hlp", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("depend_further", "a"))); - } - - private static void verifyAnswerSetsStratWithFacts(Set answerSets) { - TestUtils.assertAnswerSetsEqual("req(a), req(b), incomp(b), base(a), depend_base(a,a), dep_b_hlp(a), depend_further(a)", answerSets); - } - - private static void verifyProgramEquality(CompiledProgram evaluated) { - assertEquals(0, evaluated.getRules().size()); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("equal"))); - } - - private static void verifyAnswerSetsEquality(Set answerSets) { - TestUtils.assertAnswerSetsEqual("equal", answerSets); - } - - private static void verifyProgramEqualityWithVar(CompiledProgram evaluated) { - assertEquals(0, evaluated.getRules().size()); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newConstant(1)))); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("c", 1), Terms.newConstant(2)))); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("d", 1), Terms.newConstant(3)))); - } - - private static void verifyAnswerSetsEqualityWithVar(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a(1), a(2), a(3), b(1), c(2), d(3)", answerSets); - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java index 96a4c6e11..f4ec2ce48 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java @@ -10,6 +10,7 @@ import java.util.Map; import java.util.Set; +import at.ac.tuwien.kr.alpha.test.RuleParser; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; @@ -24,7 +25,6 @@ import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; public class AggregateRewritingRuleAnalysisTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java index 32df51f6f..6edbd02ed 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java @@ -32,15 +32,16 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java index 96d0e0626..b5d69b652 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java @@ -124,7 +124,7 @@ private void createChoiceAtom() { private void createRuleAtom() { BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); CompiledRule ruleAA = new InternalRule(Heads.newNormalHead(atomAA), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); + Collections.singleton(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); atomStore.putIfAbsent(new RuleAtom(ruleAA, new BasicSubstitution())); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java index 9edb1fe89..faa380f8e 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java @@ -35,13 +35,14 @@ import java.util.function.Predicate; import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; @@ -49,7 +50,6 @@ import at.ac.tuwien.kr.alpha.core.grounder.NaiveGrounder; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.NaiveNoGoodStore; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java similarity index 94% rename from alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java rename to alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java index ee00c7c4b..d66576a44 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.test.util; +package at.ac.tuwien.kr.alpha.test; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index dcc85fdec..9905d39f5 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -65,7 +65,7 @@ protected ActionImplementationProvider newActionImplementationProvider() { return new DefaultActionImplementationProvider(); } - protected Alpha buildInstance(SystemConfig cfg) { + public Alpha buildInstance(SystemConfig cfg) { ActionImplementationProvider actionImplementationProvider = newActionImplementationProvider(); ProgramParser parser = new ProgramParserImpl(actionImplementationProvider, Collections.emptyMap()); ProgramTransformation programNormalizer = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 78631d11b..f24c9df63 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2017-2019, the Alpha Team. * All rights reserved. - * + *

* Additional changes made by Siemens. - * + *

* Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + *

* 1) Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * + * list of conditions and the following disclaimer. + *

* 2) Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - * + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + *

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -79,9 +79,7 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); private final ProgramParser parser; - private final ProgramTransformation programNormalization; - private final Supplier stratifiedEvaluationFactory; private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; @@ -90,11 +88,11 @@ public class AlphaImpl implements Alpha { private final boolean sortAnswerSets; AlphaImpl(ProgramParser parser, ProgramTransformation programNormalization, - Supplier stratifiedEvaluationFactory, - GrounderFactory grounderFactory, - SolverFactory solverFactory, - Reifier reifier, - boolean sortAnswerSets) { + Supplier stratifiedEvaluationFactory, + GrounderFactory grounderFactory, + SolverFactory solverFactory, + Reifier reifier, + boolean sortAnswerSets) { this.parser = parser; this.programNormalization = programNormalization; this.stratifiedEvaluationFactory = stratifiedEvaluationFactory; @@ -122,7 +120,7 @@ public InputProgram readProgram(InputConfig cfg) throws IOException { @Override public InputProgram readProgramFiles(boolean literate, Map externals, List paths) throws IOException { - return readProgramFiles(literate, externals, paths.stream().map(Paths::get).collect(Collectors.toList()).toArray(new Path[] {})); + return readProgramFiles(literate, externals, paths.stream().map(Paths::get).collect(Collectors.toList()).toArray(new Path[]{})); } @Override @@ -213,7 +211,7 @@ public Stream solve(NormalProgram program, java.util.function.Predica /** * Solves the given program and filters answer sets based on the passed predicate. - * + * * @param program an {@link InternalProgram} to solve * @param filter {@link Predicate} filtering {@link at.ac.tuwien.kr.alpha.api.programs.Predicate}s in the returned answer sets * @return a Stream of answer sets representing stable models of the given program @@ -226,7 +224,7 @@ private Stream solve(CompiledProgram program, java.util.function.Pred /** * Prepares a solver (and accompanying grounder) instance pre-loaded with the given program. Use this if the * solver is needed after reading answer sets (e.g. for obtaining statistics). - * + * * @param program the program to solve. * @param filter a (java util) predicate that filters (asp-)predicates which should be contained in the answer * set stream from the solver. diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index b52ab8273..c954bfb46 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -3,7 +3,6 @@ import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; @@ -46,7 +45,7 @@ public class ActionsTest { @Test public void helloWorld() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = alphaFactory.buildInstance(new SystemConfig()); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); assertEquals("Hello World!", alphaFactory.getActionImplementationMock().getStdoutContent()); @@ -62,7 +61,7 @@ public void writeToFile() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); alphaFactory.getActionImplementationMock().setMockedFileOutputs(mockedFileOutputs); ActionImplementationProvider actionProvider = alphaFactory.getActionImplementationMock(); - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = alphaFactory.buildInstance(new SystemConfig()); InputProgram program = alpha.readProgramString(WRITE_TO_FILE); Set answerSets = alpha.solve(program).collect(Collectors.toSet()); LOGGER.debug("Got answer sets: {}", answerSets); @@ -70,7 +69,7 @@ public void writeToFile() { AnswerSet answerSet = answerSets.stream().findFirst().get(); /* * Note: We have to check answer set content here because we have no way of constructing an equal instance for - * the outputStreamHandle that is constructed when execution the "fileOutputStream" action. * + * the outputStreamHandle that is constructed when executing the "fileOutputStream" action. * */ assertEquals(1, answerSet.query(Atoms.query(Predicates.getPredicate("outfile_open_result", 2)) .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java index 13df2386e..9481ebc5f 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java @@ -1,15 +1,15 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; +package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateLiteralSplitting; +import at.ac.tuwien.kr.alpha.test.RuleParser; +import org.junit.jupiter.api.Test; import java.util.List; -import org.junit.jupiter.api.Test; - -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateLiteralSplittingTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java index 3b8870c04..72ecd207b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java @@ -1,10 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; @@ -17,7 +11,11 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateOperatorNormalization; +import at.ac.tuwien.kr.alpha.test.RuleParser; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class AggregateOperatorNormalizationTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java index a4805b8b3..e872f081e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java @@ -1,14 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.Map; -import java.util.Set; -import java.util.function.Predicate; - -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -19,7 +9,17 @@ import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.Set; +import java.util.function.Predicate; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateRewritingContextTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java index e4ca8acf3..245304cc5 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java @@ -1,36 +1,22 @@ package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.List; -import java.util.function.Function; -import java.util.stream.Collectors; - import at.ac.tuwien.kr.alpha.api.Alpha; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateRewritingTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index bbcb22734..3c6e195de 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -1,17 +1,5 @@ package at.ac.tuwien.kr.alpha; -import static java.util.stream.Collectors.toList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; @@ -22,10 +10,21 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static java.util.stream.Collectors.toList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * Copyright (c) 2021, the Alpha Team. diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java index 9915ef7b0..530040d78 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java @@ -1,31 +1,22 @@ package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; - -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; public class FixedInterpretationLiteralsTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index 7b075979e..f099fb724 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -23,13 +23,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.grounder; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.List; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; @@ -39,10 +33,12 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; -/** - * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. - */ public class RuleToStringTest { private final ProgramParser parser = new ProgramParserImpl(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java index 19ec176cb..7c6c5fdae 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java @@ -27,49 +27,32 @@ */ package at.ac.tuwien.kr.alpha; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.IOException; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.function.Function; -import java.util.stream.Collectors; - import at.ac.tuwien.kr.alpha.api.Alpha; -import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; +import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class StratifiedEvaluationTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index c26b6c66d..9b25373ec 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -163,7 +163,7 @@ public void addsFacts() { List things = asList(a, b); InputProgram program = Programs.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build())); + Set expected = Set.of(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build()); assertEquals(expected, actual); } @@ -678,6 +678,7 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep // Detailed reproduction test-case for github issue #239. @Test + @Disabled("This test relies on stratified evaluation being disabled, which is not supported anymore.") public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { final ProgramParser parser = new ProgramParserImpl(); InputProgramBuilder bld = Programs.builder(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java index c992ae820..65556fc3e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java @@ -27,16 +27,6 @@ */ package at.ac.tuwien.kr.alpha.regressiontests; -import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; -import static java.util.Collections.singleton; -import static org.junit.jupiter.api.Assertions.*; - -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.SortedSet; - import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; @@ -49,11 +39,15 @@ import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; +import java.util.*; + +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; +import static java.util.Collections.singleton; +import static org.junit.jupiter.api.Assertions.*; + public class SolverTests { private static class Thingy implements Comparable { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java index db0f40009..ada29162d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java @@ -113,7 +113,7 @@ public void runTest(String aspString, Consumer programVerifier, LOGGER.debug("Testing ASP String {}", aspString); // Parse and pre-evaluate program // Alpha instance with default config, stratified evaluation enabled - Alpha alpha =AlphaFactory.newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram input = alpha.readProgramString(aspString); DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(input); NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java index 0629c8be1..c4301385b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java @@ -1,16 +1,5 @@ package at.ac.tuwien.kr.alpha.regressiontests.util; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqualWithBase; -import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; - -import java.time.Duration; -import java.util.Set; -import java.util.stream.Collectors; - -import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.function.Executable; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; @@ -19,6 +8,16 @@ import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.function.Executable; + +import java.time.Duration; +import java.util.Set; +import java.util.stream.Collectors; + +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqualWithBase; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; public final class RegressionTestUtils { @@ -38,7 +37,7 @@ public static Solver buildSolverForRegressionTest(String programString, SystemCo } public static Solver buildSolverForRegressionTest(InputProgram program, SystemConfig cfg) { - Alpha alpha =AlphaFactory.newAlpha(cfg); + Alpha alpha = AlphaFactory.newAlpha(cfg); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java index 82d6863d0..fffd0cd20 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java @@ -8,6 +8,7 @@ public class MockedActionsAlphaFactory extends AlphaFactory { private MockActionImplementationProvider actionImplementationMock = new MockActionImplementationProvider(""); + public MockActionImplementationProvider getActionImplementationMock() { return actionImplementationMock; } @@ -16,6 +17,7 @@ public void setActionImplementationMock(MockActionImplementationProvider actionI this.actionImplementationMock = actionImplementationMock; } + @Override protected ActionImplementationProvider newActionImplementationProvider() { return actionImplementationMock; }