def removeComponent(self, c): """ generated source for method removeComponent """ if isinstance(c, (Proposition, )): if self.basePropositions.containsKey(name): self.basePropositions.remove(name) elif self.inputPropositions.containsKey(name): self.inputPropositions.remove(name) if partner != None: self.legalInputMap.remove(partner) self.legalInputMap.remove(p) elif name == GdlPool.getProposition(GdlPool.getConstant("INIT")): raise RuntimeException("The INIT component cannot be removed. Consider leaving it and ignoring it.") elif name == GdlPool.getProposition(GdlPool.getConstant("terminal")): raise RuntimeException("The terminal component cannot be removed.") else: for propositions in legalPropositions.values(): if self.propositions.contains(p): self.propositions.remove(p) if partner != None: self.legalInputMap.remove(partner) self.legalInputMap.remove(p) for propositions in goalPropositions.values(): self.propositions.remove(p) self.propositions.remove(p) self.components.remove(c) for parent in c.getInputs(): parent.removeOutput(c) for child in c.getOutputs(): child.removeInput(c)
def normalizePropositions(cls, componentSet): """ generated source for method normalizePropositions """ for component in componentSet: if isinstance(component, (Proposition, )): if isinstance(sentence, (GdlRelation, )): if relation.__name__ == cls.NEXT: p.setName(GdlPool.getProposition(GdlPool.getConstant("anon")))
def applyCondensation(cls, condensationSet, rule, sentenceNameSource): """ generated source for method applyCondensation """ varsInCondensationSet = HashSet() for literal in condensationSet: varsInCondensationSet.addAll(GdlUtils.getVariables(literal)) varsToKeep = HashSet() for literal in condensationSet: varsToKeep.addAll(GdlUtils.getVariables(literal)) varsToKeep2 = HashSet() varsToKeep2.addAll(GdlUtils.getVariables(rule.getHead())) for literal in rule.getBody(): if not condensationSet.contains(literal): varsToKeep2.addAll(GdlUtils.getVariables(literal)) varsToKeep.retainAll(varsToKeep2) orderedVars = ArrayList(varsToKeep) condenserName = sentenceNameSource.getNameWithPrefix(rule.getHead().__name__) condenserHead = GdlSentence() if orderedVars.isEmpty(): condenserHead = GdlPool.getProposition(condenserName) else: condenserHead = GdlPool.getRelation(condenserName, orderedVars) condenserBody = ArrayList(condensationSet) condenserRule = GdlPool.getRule(condenserHead, condenserBody) remainingLiterals = ArrayList() for literal in rule.getBody(): if not condensationSet.contains(literal): remainingLiterals.add(literal) remainingLiterals.add(condenserHead) modifiedRule = GdlPool.getRule(rule.getHead(), remainingLiterals) newRules = ArrayList(2) newRules.add(condenserRule) newRules.add(modifiedRule) return newRules
def cleanParentheses_1(cls, sentence): """ generated source for method cleanParentheses_1 """ if isinstance(sentence, (GdlProposition, )): return sentence cleanedBody = ArrayList() for term in sentence.getBody(): cleanedBody.add(cls.cleanParentheses(term)) if len(cleanedBody) == 0: return GdlPool.getProposition(sentence.__name__) else: return GdlPool.getRelation(sentence.__name__, cleanedBody)
def setUpInit(cls, components, trueComponent, falseComponent): """ generated source for method setUpInit """ initProposition = Proposition(GdlPool.getProposition(cls.INIT_CAPS)) for entry in components.entrySet(): # Is this something that will be true? if entry.getValue() == trueComponent: if entry.getKey().__name__ == cls.INIT: if trueSentenceComponent.getInputs().isEmpty(): transition.addInput(initProposition) initProposition.addOutput(transition) trueSentenceComponent.addInput(transition) transition.addOutput(trueSentenceComponent) else: input.removeOutput(transition) transition.removeInput(input) orInputs.add(input) orInputs.add(initProposition) orify(orInputs, transition, falseComponent)
def fixDisjunctions(self): """ generated source for method fixDisjunctions """ fixList = ArrayList() for proposition in propositions.values(): if proposition.getInputs().size() > 1: fixList.add(proposition) for fixItem in fixList: for input in fixItem.getInputs(): i += 1 if isinstance(, (GdlProposition, )): disjunct = Proposition(GdlPool.getProposition(GdlPool.getConstant(proposition.__name__.getValue() + "-" + i))) else: disjunct = Proposition(GdlPool.getRelation(GdlPool.getConstant(relation.__name__.getValue() + "-" + i), relation.getBody())) input.getOutputs().clear() link(input, disjunct) link(disjunct, or_) self.components.add(disjunct) fixItem.getInputs().clear() link(or_, fixItem) self.components.add(or_)
def getSentenceFromTuple(self, tuple_): """ generated source for method getSentenceFromTuple """ if len(tuple_) != self.tupleSize: raise IllegalArgumentException("Passed tuple of the wrong size to a sentence form: " + "tuple was " + tuple_ + ", sentence form is " + self) if len(tuple_) < self.arity: raise IllegalStateException("Something is very wrong, probably fixable by the GdlCleaner; name: " + self.name + "; arity: " + self.arity + "; tupleSize: " + self.tupleSize) sentenceBody = Lists.newArrayList() curIndex = 0 i = 0 while i < self.arity: Preconditions.checkArgument(not (isinstance(term, (GdlFunction, )))) if self.functions.containsKey(i): sentenceBody.add(functionForm.getFunctionFromTuple(tuple_, curIndex)) curIndex += functionForm.getTupleSize() else: sentenceBody.add(term) curIndex += 1 i += 1 if self.arity == 0: return GdlPool.getProposition(self.name) else: return GdlPool.getRelation(self.name, sentenceBody)