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 getVarsInLiveConjuncts(cls, rule, constantSentenceForms): """ generated source for method getVarsInLiveConjuncts """ result = HashSet() for literal in rule.getBody(): if isinstance(literal, (GdlRelation, )): if not SentenceModelUtils.inSentenceFormGroup(literal, constantSentenceForms): result.addAll(GdlUtils.getVariables(literal)) elif isinstance(literal, (GdlNot, )): if not SentenceModelUtils.inSentenceFormGroup(inner, constantSentenceForms): result.addAll(GdlUtils.getVariables(literal)) return result
def __init___1(self, parent, i): """ generated source for method __init___1 """ super(IterationOrderCandidate, self).__init__() # Shared rules: self.varsToAssign = parent.varsToAssign self.sourceConjunctCandidates = parent.sourceConjunctCandidates self.sourceConjunctSizes = parent.sourceConjunctSizes self.functionalSentences = parent.functionalSentences self.functionalSentencesInfo = parent.functionalSentencesInfo self.varDomainSizes = parent.varDomainSizes # Individual rules: self.sourceConjunctIndices = ArrayList(parent.sourceConjunctIndices) self.varOrdering = ArrayList(parent.varOrdering) self.functionalConjunctIndices = ArrayList(parent.functionalConjunctIndices) self.varSources = ArrayList(parent.varSources) # Add the new source conjunct self.sourceConjunctIndices.add(i) sourceConjunctCandidate = self.sourceConjunctCandidates.get(i) varsFromConjunct = GdlUtils.getVariables(sourceConjunctCandidate) # Ignore both previously added vars and duplicates # Oh, but we need to be careful here, at some point. # i.e., what if there are multiple of the same variable # in a single statement? # That should probably be handled later. for var in varsFromConjunct: if not self.varOrdering.contains(var): self.varOrdering.add(var) self.varSources.add(i) self.functionalConjunctIndices.add(-1)
def getBestVariable(self, functionalSentence, functionInfo): """ generated source for method getBestVariable """ # If all the variables that can be set by the functional sentence are in # the varOrdering, we return null. Otherwise, we return one of # those with the largest domain. # The FunctionInfo is sentence-independent, so we need the context # of the sentence (which has variables in it). tuple_ = GdlUtils.getTupleFromSentence(functionalSentence) dependentSlots = functionInfo.getDependentSlots() if len(tuple_) != len(dependentSlots): raise RuntimeException("Mismatched sentence " + functionalSentence + " and constant form " + functionInfo) candidateVars = HashSet() i = 0 while i < len(tuple_): if isinstance(term, (GdlVariable, )) and dependentSlots.get(i) and not self.varOrdering.contains(term) and self.varsToAssign.contains(term): candidateVars.add(term) i += 1 # Now we look at the domains, trying to find the largest bestVar = None bestDomainSize = 0 for var in candidateVars: if domainSize > bestDomainSize: bestVar = var bestDomainSize = domainSize return bestVar
def allVarsInLiteralAlreadySet(cls, literal, setVars): """ generated source for method allVarsInLiteralAlreadySet """ varsInLiteral = GdlUtils.getVariables(literal) for varInLiteral in varsInLiteral: if not setVars.contains(varInLiteral): return False return True
def __init___2(self, parent, functionalSentence, functionalSentenceIndex, functionOutput): """ generated source for method __init___2 """ super(IterationOrderCandidate, self).__init__() # Shared rules: self.varsToAssign = parent.varsToAssign self.sourceConjunctCandidates = parent.sourceConjunctCandidates self.sourceConjunctSizes = parent.sourceConjunctSizes self.functionalSentences = parent.functionalSentences self.functionalSentencesInfo = parent.functionalSentencesInfo self.varDomainSizes = parent.varDomainSizes # Individual rules: self.sourceConjunctIndices = ArrayList(parent.sourceConjunctIndices) self.varOrdering = ArrayList(parent.varOrdering) self.functionalConjunctIndices = ArrayList(parent.functionalConjunctIndices) self.varSources = ArrayList(parent.varSources) # And we add the function varsInFunction = GdlUtils.getVariables(functionalSentence) # First, add the remaining arguments for var in varsInFunction: if not self.varOrdering.contains(var) and not var == functionOutput and self.varsToAssign.contains(var): self.varOrdering.add(var) self.functionalConjunctIndices.add(-1) self.varSources.add(-1) # Then the output self.varOrdering.add(functionOutput) self.functionalConjunctIndices.add(functionalSentenceIndex) self.varSources.add(-1)
def getTurnsConjunctsArePossible(self, body): """ generated source for method getTurnsConjunctsArePossible """ # We want to identify the conjuncts that are used by the # game flow. relevantLiterals = ArrayList() for literal in body: if isinstance(literal, (GdlSentence, )): if SentenceModelUtils.inSentenceFormGroup(sentence, self.formsControlledByFlow): relevantLiterals.add(literal) elif isinstance(literal, (GdlNot, )): if SentenceModelUtils.inSentenceFormGroup(innerSentence, self.formsControlledByFlow): relevantLiterals.add(literal) # If none are related to the game flow, then that's it. It can # happen on any turn. # if(relevantLiterals.isEmpty()) # return getCompleteTurnSet(); turnsPossible = HashSet(getCompleteTurnSet()) # For each of the relevant literals, we need to see if there are assignments # such that for literal in relevantLiterals: if isinstance(literal, (GdlSentence, )): while t < self.getNumTurns(): if self.sentencesTrueByTurn.get(t).contains(literal): turns.add(t) else: for s in sentencesTrueByTurn.get(t): # Could be true if there's an assignment if None != GdlUtils.getAssignmentMakingLeftIntoRight(literal, s): turns.add(t) break t += 1 elif isinstance(literal, (GdlNot, )): while t < self.getNumTurns(): if not self.sentencesTrueByTurn.get(t).contains(internal): turns.add(t) else: for s in sentencesTrueByTurn.get(t): if None != GdlUtils.getAssignmentMakingLeftIntoRight(internal, s): turns.add(t) break t += 1 # Accumulate turns # Note that all relevant conjuncts must be true, so this # is an intersection of when the individual conjuncts # could be true. turnsPossible.retainAll(turns) return turnsPossible
def replaceVariablesAndConstants(self, function_): """ generated source for method replaceVariablesAndConstants """ assignment = Maps.newHashMap() termsToReplace = Sets.newHashSet() GdlVisitors.visitAll(function_, GdlVisitor()) for var in GdlUtils.getVariables(function_): assignment.put(var, getUnusedVariable()) return CommonTransforms.replaceVariables(function_, assignment)
def getReplacementAssignment(self, sentence, varGen): """ generated source for method getReplacementAssignment """ Preconditions.checkArgument(self.applies(sentence)) assignment = Maps.newHashMap() tuple_ = GdlUtils.getTupleFromSentence(sentence) for varIndex in replacementsByOriginalTupleIndex.keySet(): assignment.put(tuple_.get(varIndex), replacementFunction) return assignment
def addSentenceForms(self, ordering, trueFlowSentences, model, functionInfoMap): """ generated source for method addSentenceForms """ for curForm in ordering: # Check against trueFlowSentences, add to trueFlowSentences # or check against constantForms if necessary # Use basic Assignments class, of course for alwaysTrueSentences in model.getSentencesListedAsTrue(curForm): trueFlowSentences.add(alwaysTrueSentences) for rule in model.getRules(curForm): while asnItr.hasNext(): if trueFlowSentences.contains(transformedHead): asnItr.changeOneInNext(varsInHead, assignment) # Go through the conjuncts for literal in rule.getBody(): if isinstance(literal, (GdlSentence, )): if curForm.matches(literal): raise RuntimeException("Haven't implemented recursion in the game flow") if self.constantForms.contains(conjForm): if not self.constantChecker.isTrueConstant(transformed): isGoodAssignment = False asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) else: if not trueFlowSentences.contains(transformed): # False sentence isGoodAssignment = False asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) elif isinstance(literal, (GdlNot, )): if self.constantForms.contains(conjForm): if self.constantChecker.isTrueConstant(transformed): isGoodAssignment = False asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) else: if trueFlowSentences.contains(transformed): # False sentence isGoodAssignment = False asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) # Nothing else needs attention, really # We've gone through all the conjuncts and are at the # end of the rule if isGoodAssignment: trueFlowSentences.add(transformedHead) if varsInHead.isEmpty(): break else: asnItr.changeOneInNext(varsInHead, assignment)
def getVarDomainInRuleBody(cls, varInHead, rule, newPossibleConstantsByForm, curDomain, model): """ generated source for method getVarDomainInRuleBody """ try: for conjunct in getPositiveConjuncts(rule.getBody()): if GdlUtils.getVariables(conjunct).contains(varInHead): domains.add(getVarDomainInSentence(varInHead, conjunct, newPossibleConstantsByForm, curDomain, model)) return getIntersection(domains) except RuntimeException as e: raise RuntimeException("Error in rule " + rule + " for variable " + varInHead, e)
def applies(self, sentence): """ generated source for method applies """ if not self.original.matches(sentence): return False tuple_ = GdlUtils.getTupleFromSentence(sentence) for varIndex in replacementsByOriginalTupleIndex.keySet(): if not (isinstance(, (GdlVariable, ))): return False return True
def getNewFormDomain(cls, condensingRule, oldModel, newForm): """ generated source for method getNewFormDomain """ varDomains = SentenceDomainModels.getVarDomains(condensingRule, oldModel, VarDomainOpts.BODY_ONLY) domainsForSlots = Lists.newArrayList() for term in GdlUtils.getTupleFromSentence(condensingRule.getHead()): if not (isinstance(term, (GdlVariable, ))): raise RuntimeException("Expected all slots in the head of a condensing rule to be variables, but the rule was: " + condensingRule) domainsForSlots.add(varDomains.get(term)) return CartesianSentenceFormDomain.create(newForm, domainsForSlots)
def reinsertLiteralInRightPlace(cls, ruleBody, literalToReinsert): """ generated source for method reinsertLiteralInRightPlace """ setVars = Sets.newHashSet() i = 0 while i < len(ruleBody): if isinstance(literal, (GdlSentence, )): setVars.addAll(GdlUtils.getVariables(literal)) if allVarsInLiteralAlreadySet(literalToReinsert, setVars): ruleBody.add(i + 1, literalToReinsert) return i += 1
def getBestIterationOrderCandidate(cls, rule, varDomains, functionInfoMap, completedSentenceFormSizes, preassignment, analyticFunctionOrdering): """ generated source for method getBestIterationOrderCandidate """ # SentenceModel model, # Here are the things we need to pass into the first IOC constructor sourceConjunctCandidates = ArrayList() # What is a source conjunct candidate? # - It is a positive conjunct in the rule (i.e. a GdlSentence in the body). # - It has already been fully defined; i.e. it is not recursively defined in terms of the current form. # Furthermore, we know the number of potentially true tuples in it. varsToAssign = GdlUtils.getVariables(rule) newVarsToAssign = ArrayList() for var in varsToAssign: if not newVarsToAssign.contains(var): newVarsToAssign.add(var) varsToAssign = newVarsToAssign if preassignment != None: varsToAssign.removeAll(preassignment.keySet()) # Calculate var domain sizes varDomainSizes = getVarDomainSizes(varDomains)# rule, model sourceConjunctSizes = ArrayList() for conjunct in rule.getBody(): if isinstance(conjunct, (GdlRelation, )): if completedSentenceFormSizes != None and completedSentenceFormSizes.containsKey(form): # New: Don't add if it will be useless as a source # For now, we take a strict definition of that # Compare its size with the product of the domains # of the variables it defines # In the future, we could require a certain ratio # to decide that this is worthwhile for var in vars: maxSize *= domainSize if size >= maxSize: continue sourceConjunctCandidates.add(relation) sourceConjunctSizes.add(size) functionalSentences = ArrayList() functionalSentencesInfo = ArrayList() for conjunct in rule.getBody(): if isinstance(conjunct, (GdlSentence, )): if functionInfoMap != None and functionInfoMap.containsKey(form): functionalSentences.add(conjunct) functionalSentencesInfo.add(functionInfoMap.get(form)) # TODO: If we have a head assignment, treat everything as already replaced # Maybe just translate the rule? Or should we keep the pool clean? emptyCandidate = IterationOrderCandidate(varsToAssign, sourceConjunctCandidates, sourceConjunctSizes, functionalSentences, functionalSentencesInfo, varDomainSizes) searchQueue = PriorityQueue() searchQueue.add(emptyCandidate) while not searchQueue.isEmpty(): # print "Node being checked out: " + curNode; if curNode.isComplete(): # This is the complete ordering with the lowest heuristic value return curNode searchQueue.addAll(curNode.getChildren(analyticFunctionOrdering)) raise RuntimeException("Found no complete iteration orderings")
def applyRuleBodyOnlyPropagation(cls, neededConstantsByForm, curDomains, model): """ generated source for method applyRuleBodyOnlyPropagation """ somethingChanged = False for rule in getRules(model.getDescription()): for var in ImmutableSet.copyOf(GdlUtils.getVariables(rule)): if not varsInHead.contains(var): if neededConstants == None: raise IllegalStateException("var is " + var + ";\nvarDomains key set is " + varDomains.keySet() + ";\nvarsInHead is " + varsInHead + ";\nrule is " + rule) for conjunct in rule.getBody(): somethingChanged |= addPossibleValuesToConjunct(neededConstants, conjunct, var, neededConstantsByForm, model) return somethingChanged
def getRuleResults(self, rule, domainModel, sentencesSoFar): """ generated source for method getRuleResults """ ConcurrencyUtils.checkForInterruption() headForm = self.model.getSentenceForm(rule.getHead()) varDomains = SentenceDomainModels.getVarDomains(rule, domainModel, VarDomainOpts.INCLUDE_HEAD) functionInfoMap = sentencesSoFar.getFunctionInfo() completedSentenceFormValues = sentencesSoFar.getSentences().asMap() assignments = AssignmentsImpl(rule, varDomains, functionInfoMap, completedSentenceFormValues) asnItr = assignments.getIterator() sentencesToAdd = GdlSentenceSet.create() while asnItr.hasNext(): for literal in rule.getBody(): ConcurrencyUtils.checkForInterruption() if not satisfies(assignment, literal, sentencesSoFar.getSentences()): asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) allSatisfied = False break if allSatisfied: sentencesToAdd.put(headForm, CommonTransforms.replaceVariables(head, assignment)) asnItr.changeOneInNext(GdlUtils.getVariables(head), assignment) return sentencesToAdd
def getVarDomainInSentence(cls, var, conjunct, newPossibleConstantsByForm, curDomain, model): """ generated source for method getVarDomainInSentence """ form = model.getSentenceForm(conjunct) tuple_ = GdlUtils.getTupleFromSentence(conjunct) domains = Lists.newArrayList() i = 0 while i < len(tuple_): if tuple_.get(i) == var: domains.add(newPossibleConstantsByForm.get(form).get(i)) domains.add(curDomain.get(form).get(i)) i += 1 return getIntersection(domains)
def addRuleResultsForChosenLiteral(self, rule, chosenLiteral, chosenNewSentences, domainModel, allSentences, sentencesToAdd): """ generated source for method addRuleResultsForChosenLiteral """ headForm = self.model.getSentenceForm(rule.getHead()) varDomains = SentenceDomainModels.getVarDomains(rule, domainModel, VarDomainOpts.INCLUDE_HEAD) functionInfoMap = allSentences.getFunctionInfo() completedSentenceFormValues = allSentences.getSentences().asMap() for chosenNewSentence in chosenNewSentences: if preassignments != None: while asnItr.hasNext(): for literal in rule.getBody(): if literal == chosenLiteral: # Already satisfied continue if not self.satisfies(assignment, literal, allSentences.getSentences()): asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment) allSatisfied = False break if allSatisfied: if not allSentences.containsSentence(headForm, newHead): sentencesToAdd.put(headForm, newHead) asnItr.changeOneInNext(GdlUtils.getVariables(head), assignment)
def findDistinctOrNotToMoveIndex(cls, ruleBody): """ generated source for method findDistinctOrNotToMoveIndex """ setVars = Sets.newHashSet() i = 0 while i < len(ruleBody): if isinstance(literal, (GdlSentence, )): setVars.addAll(GdlUtils.getVariables(literal)) elif isinstance(literal, (GdlDistinct, )) or isinstance(literal, (GdlNot, )): if not allVarsInLiteralAlreadySet(literal, setVars): return i i += 1 return None
def getVarsToModelsMap(self, rule): """ generated source for method getVarsToModelsMap """ varsToUse = Sets.newHashSet(GdlUtils.getVariables(rule.getHead())) varsToModelsMap = Maps.newHashMap() for var in varsToUse: varsToModelsMap.put(var, TermModel()) for literal in rule.getBody(): if isinstance(literal, (GdlRelation, )): if not self.sentencesModel.containsKey(nameAndArity): self.sentencesModel.put(nameAndArity, getNTermModels(nameAndArity.getArity())) addVariablesToMap(literalBody, literalModel, varsToModelsMap) return varsToModelsMap
def getCondensationSet(cls, rule, model, checker, sentenceNameSource): """ generated source for method getCondensationSet """ varsInRule = GdlUtils.getVariables(rule) varsInHead = GdlUtils.getVariables(rule.getHead()) varsNotInHead = ArrayList(varsInRule) varsNotInHead.removeAll(varsInHead) for var in varsNotInHead: ConcurrencyUtils.checkForInterruption() for literal in rule.getBody(): if GdlUtils.getVariables(literal).contains(var): minSet.add(literal) for literal in minSet: if isinstance(literal, (GdlRelation, )): varsSupplied.addAll(GdlUtils.getVariables(literal)) elif isinstance(literal, (GdlDistinct, )) or isinstance(literal, (GdlNot, )): varsNeeded.addAll(GdlUtils.getVariables(literal)) varsNeeded.removeAll(varsSupplied) if not varsNeeded.isEmpty(): continue for varNeeded in varsNeeded: for literal in rule.getBody(): if isinstance(literal, (GdlRelation, )): if GdlUtils.getVariables(literal).contains(varNeeded): suppliers.add(literal) candidateSuppliersList.add(suppliers) for suppliers in candidateSuppliersList: if Collections.disjoint(suppliers, literalsToAdd): literalsToAdd.add(suppliers.iterator().next()) minSet.addAll(literalsToAdd) if goodCondensationSetByHeuristic(minSet, rule, model, checker, sentenceNameSource): return minSet return None
def addConstantsFromSentenceIfInOldDomain(cls, newConstantsByForm, oldDomain, model, sentence): """ generated source for method addConstantsFromSentenceIfInOldDomain """ form = model.getSentenceForm(sentence) tuple_ = GdlUtils.getTupleFromSentence(sentence) if len(tuple_) != form.getTupleSize(): raise IllegalStateException() i = 0 while i < form.getTupleSize(): ConcurrencyUtils.checkForInterruption() if isinstance(term, (GdlConstant, )): if oldDomainForTerm.contains(term): newConstantsByForm.get(form).put(i, term) i += 1
def propagatePossibleConstants(cls, newPossibleConstantsByForm, curDomain, model): """ generated source for method propagatePossibleConstants """ # Injection: Go from the intersections of variable values in rules to the # values in their heads somethingChanged = False for rule in getRules(model.getDescription()): for varInHead in ImmutableSet.copyOf(GdlUtils.getVariables(rule.getHead())): domainsOfHeadVars.put(varInHead, domain) somethingChanged |= addPossibleValuesToSentence(domain, head, varInHead, newPossibleConstantsByForm, model) # Language-based injections somethingChanged |= applyLanguageBasedInjections(GdlPool.INIT, GdlPool.TRUE, newPossibleConstantsByForm) somethingChanged |= applyLanguageBasedInjections(GdlPool.NEXT, GdlPool.TRUE, newPossibleConstantsByForm) somethingChanged |= applyLanguageBasedInjections(GdlPool.LEGAL, GdlPool.DOES, newPossibleConstantsByForm) return somethingChanged
def addPossibleValuesToSentence(cls, neededAndPossibleConstants, sentence, curVar, neededConstantsByForm, model): """ generated source for method addPossibleValuesToSentence """ ConcurrencyUtils.checkForInterruption() somethingChanged = False form = model.getSentenceForm(sentence) tuple_ = GdlUtils.getTupleFromSentence(sentence) Preconditions.checkArgument(form.getTupleSize() == len(tuple_)) i = 0 while i < len(tuple_): if tuple_.get(i) == curVar: Preconditions.checkNotNull(neededConstantsByForm.get(form)) Preconditions.checkNotNull(neededAndPossibleConstants) somethingChanged |= neededConstantsByForm.get(form).putAll(i, neededAndPossibleConstants) i += 1 return somethingChanged
def getProducibleVars(self, sentence): """ generated source for method getProducibleVars """ if not self.form.matches(sentence): raise RuntimeException("Sentence " + sentence + " does not match constant form") tuple_ = GdlUtils.getTupleFromSentence(sentence) candidateVars = HashSet() # Variables that appear multiple times go into multipleVars multipleVars = HashSet() # ...which, of course, means we have to spot non-candidate vars nonCandidateVars = HashSet() i = 0 while i < len(tuple_): if isinstance(term, (GdlVariable,)) and not multipleVars.contains(term): if candidateVars.contains(var) or nonCandidateVars.contains(var): multipleVars.add(var) candidateVars.remove(var) elif self.dependentSlots.get(i): candidateVars.add(var) else: nonCandidateVars.add(var) i += 1 return candidateVars
def __init__(self, headAssignment, rule, varDomains, functionInfoMap, completedSentenceFormValues): """ generated source for method __init__ """ super(AssignmentsImpl, self).__init__() self.empty = False self.headAssignment = headAssignment # We first have to find the remaining variables in the body self.varsToAssign = GdlUtils.getVariables(rule) # Remove all the duplicates; we do, however, want to keep the ordering newVarsToAssign = ArrayList() for v in varsToAssign: if not newVarsToAssign.contains(v): newVarsToAssign.add(v) self.varsToAssign = newVarsToAssign self.varsToAssign.removeAll(headAssignment.keySet()) # varsToAssign is set at this point # We see if iterating over entire tuples will give us a # better result, and we look for the best way of doing that. # Let's get the domains of the variables # Map<GdlVariable, Set<GdlConstant>> varDomains = model.getVarDomains(rule); # Since we're looking at a particular rule, we can do this one step better # by looking at the domain of the head, which may be more restrictive # and taking the intersections of the two domains where applicable # Map<GdlVariable, Set<GdlConstant>> headVarDomains = model.getVarDomainsInSentence(rule.getHead()); # We can run the A* search for a good set of source conjuncts # at this point, then use the result to build the rest. completedSentenceFormSizes = HashMap() if completedSentenceFormValues != None: for form in completedSentenceFormValues.keySet(): completedSentenceFormSizes.put(form, completedSentenceFormValues.get(form).size()) varDomainSizes = HashMap() for var in varDomains.keySet(): varDomainSizes.put(var, varDomains.get(var).size()) bestOrdering = IterationOrderCandidate() bestOrdering = getBestIterationOrderCandidate(rule, varDomains, functionInfoMap, completedSentenceFormSizes, headAssignment, False)# model, # TODO: True here? # Want to replace next few things with order # Need a few extra things to handle the use of iteration over existing tuples self.varsToAssign = bestOrdering.getVariableOrdering() # For each of these vars, we have to find one or the other. # Let's start by finding all the domains, a task already done. self.valuesToIterate = Lists.newArrayListWithCapacity(len(self.varsToAssign)) for var in varsToAssign: if varDomains.containsKey(var): if not varDomains.get(var).isEmpty(): self.valuesToIterate.add(ImmutableList.copyOf(varDomains.get(var))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) # Okay, the iteration-over-domain is done. # Now let's look at sourced iteration. self.sourceDefiningSlot = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): self.sourceDefiningSlot.add(-1) i += 1 # We also need to convert values into tuples # We should do so while constraining to any constants in the conjunct # Let's convert the conjuncts sourceConjuncts = bestOrdering.getSourceConjuncts() self.tuplesBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<List<GdlConstant>>>(len(sourceConjuncts)); self.varsChosenBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Integer>>(len(sourceConjuncts)); self.putDontCheckBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Boolean>>(len(sourceConjuncts)); j = 0 while j < len(sourceConjuncts): # flatten into a tuple # Go through the vars/constants in the tuple while i < len(conjunctTuple): if isinstance(term, (GdlConstant, )): constraintSlots.add(i) constraintValues.add(term) # TODO: What if tuple size ends up being 0? # Need to keep that in mind elif isinstance(term, (GdlVariable, )): varsChosen.add(varIndex) if self.sourceDefiningSlot.get(varIndex) == -1: # We define it self.sourceDefiningSlot.set(varIndex, j) putDontCheck.add(True) else: # It's an overlap; we just check for consistency putDontCheck.add(False) else: raise RuntimeException("Function returned in tuple") i += 1 self.varsChosenBySource.add(ImmutableList.copyOf(varsChosen)) self.putDontCheckBySource.add(ImmutableList.copyOf(putDontCheck)) # Now we put the tuples together # We use constraintSlots and constraintValues to check that the # tuples have compatible values for sentence in sentences: # Check that it doesn't conflict with our headAssignment if not headAssignment.isEmpty(): for var in headAssignment.keySet(): if tupleAssignment.containsKey(var) and tupleAssignment.get(var) != headAssignment.get(var): continue while c < len(constraintSlots): if not longTuple.get(slot) == value: continue c += 1 while s < len(longTuple): # constraintSlots is sorted in ascending order if c < len(constraintSlots) and constraintSlots.get(c) == s: c += 1 else: shortTuple.add(longTuple.get(s)) s += 1 # The tuple fits the source conjunct tuples.add(ImmutableList.copyOf(shortTuple)) # sortTuples(tuples); //Needed? Useful? Not sure. Probably not? self.tuplesBySource.add(ImmutableList.copyOf(tuples)) j += 1 # We now want to see which we can give assignment functions to self.valuesToCompute = ArrayList(len(self.varsToAssign)) for var in varsToAssign: self.valuesToCompute.add(None) self.indicesToChangeWhenNull = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): # Change itself, why not? # Actually, instead let's try -1, to catch bugs better self.indicesToChangeWhenNull.add(-1) i += 1 # Now we have our functions already selected by the ordering # bestOrdering.functionalConjunctIndices; # Make AssignmentFunctions out of the ordering functionalConjuncts = bestOrdering.getFunctionalConjuncts() # print "functionalConjuncts: " + functionalConjuncts; i = 0 while i < len(functionalConjuncts): if functionalConjunct != None: # These are the only ones that could be constant functions if functionInfoMap != None: functionInfo = functionInfoMap.get(conjForm) if functionInfo != None: # Now we need to figure out which variables are involved # and which are suitable as functional outputs. # 1) Which vars are in this conjunct? # 2) Of these vars, which is "rightmost"? # 3) Is it only used once in the relation? if Collections.frequency(varsInSentence, rightmostVar) != 1: continue # Can't use it # 4) Which slot is it used in in the relation? # 5) Build an AssignmentFunction if appropriate. # This should be able to translate from values of # the other variables to the value of the wanted # variable. # We don't guarantee that this works until we check if not function_.functional(): continue self.valuesToCompute.set(index, function_) remainingVarsInSentence.remove(rightmostVar) self.indicesToChangeWhenNull.set(index, self.varsToAssign.indexOf(nextRightmostVar)) i += 1 # We now have the remainingVars also assigned their domains # We also cover the distincts here # Assume these are just variables and constants self.distincts = ArrayList() for literal in rule.getBody(): if isinstance(literal, (GdlDistinct, )): self.distincts.add(literal) computeVarsToChangePerDistinct() # Need to add "distinct" restrictions to head assignment, too... checkDistinctsAgainstHead()
def create_0(cls, form, initialSentences): """ generated source for method create_0 """ functionInfo = MutableFunctionInfo(form) for sentence in initialSentences: functionInfo.addTuple(GdlUtils.getTupleFromGroundSentence(sentence)) return functionInfo
def addSentence(self, sentence): """ generated source for method addSentence """ self.addTuple(GdlUtils.getTupleFromGroundSentence(sentence))
def getVarsInConjunct(cls, literal): """ generated source for method getVarsInConjunct """ return GdlUtils.getVariables(literal)