def restrictDomainsToUsefulValues(cls, oldModel): """ generated source for method restrictDomainsToUsefulValues """ # Start with everything from the current domain model. neededAndPossibleConstantsByForm = Maps.newHashMap() for form in oldModel.getSentenceForms(): neededAndPossibleConstantsByForm.put(form, HashMultimap.create()) addDomain(neededAndPossibleConstantsByForm.get(form), oldModel.getDomain(form), form) # # * To minimize the contents of the domains, we repeatedly go through two processes to reduce # * the domain: # * # * 1) We remove unneeded constants from the domain. These are constants which (in their # * position) do not contribute to any sentences with a GDL keyword as its name; that # * is, it never matters whether a sentence with that constant in that position is # * true or false. # * 2) We remove impossible constants from the domain. These are constants which cannot # * end up in their position via any rule or sentence in the game description, given # * the current domain. # * # * Constants removed because of one type of pass or the other may cause other constants # * in other sentence forms to become unneeded or impossible, so we make multiple passes # * until everything is stable. # somethingChanged = True while somethingChanged: somethingChanged = removeUnneededConstants(neededAndPossibleConstantsByForm, oldModel) somethingChanged |= removeImpossibleConstants(neededAndPossibleConstantsByForm, oldModel) return toSentenceDomainModel(neededAndPossibleConstantsByForm, oldModel)
def getDependencyGraph(cls, sentenceForms, rulesByForm): """ generated source for method getDependencyGraph """ dependencyGraph = HashMultimap.create() for entry in rulesByForm.entries(): for bodyLiteral in rule.getBody(): dependencyGraph.putAll(head, getSentenceFormsInBody(bodyLiteral, sentenceForms)) return ImmutableSetMultimap.copyOf(dependencyGraph)
def copyOf(cls, other): """ generated source for method copyOf """ if isinstance(other, (ImmutableConstantChecker, )): return other model = other.getSentenceFormModel() sentencesByForm = HashMultimap.create() for form in other.getConstantSentenceForms(): sentencesByForm.putAll(form, other.getTrueSentences(form)) return ImmutableConstantChecker(ImmutableSentenceFormModel.copyOf(model), ImmutableSetMultimap.copyOf(sentencesByForm))
def removeUnneededConstants(cls, curDomains, model): """ generated source for method removeUnneededConstants """ newNeededConstantsByForm = Maps.newHashMap() for form in curDomains.keySet(): newNeededConstantsByForm.put(form, HashMultimap.create()) populateInitialNeededConstants(newNeededConstantsByForm, curDomains, model) somethingChanged = True while somethingChanged: somethingChanged = propagateNeededConstants(newNeededConstantsByForm, curDomains, model) return retainNewDomains(curDomains, newNeededConstantsByForm)
def augmentGraphWithLanguageRules(cls, dependencyGraph, sentenceForms): """ generated source for method augmentGraphWithLanguageRules """ newGraph = HashMultimap.create() newGraph.putAll(dependencyGraph) for form in sentenceForms: if form.__name__ == GdlPool.TRUE: if sentenceForms.contains(nextForm): newGraph.put(form, nextForm) elif form.__name__ == GdlPool.DOES: if sentenceForms.contains(legalForm): newGraph.put(form, legalForm) return newGraph
def testSafeToposort(self): """ generated source for method testSafeToposort """ allElements = Sets.newHashSet(1, 2, 3, 4, 5, 6, 7, 8) graph = HashMultimap.create() graph.put(2, 1) graph.put(3, 2) graph.put(4, 2) graph.put(5, 3) graph.put(5, 4) graph.put(3, 4) graph.put(4, 3) graph.put(4, 6) graph.put(6, 7) graph.put(7, 8) graph.put(8, 3) print DependencyGraphs.toposortSafe(allElements, graph)
def __init__(self): """ generated source for method __init__ """ self.sentences = HashMultimap.create() self.functionInfoMap = Maps.newHashMap()
def reverseGraph(cls, graph): """ generated source for method reverseGraph """ return Multimaps.invertFrom(graph, HashMultimap.create())
def createStrataDependencyGraph(cls, dependencyGraph): """ generated source for method createStrataDependencyGraph """ strataDependencyGraph = HashMultimap.create() for entry in dependencyGraph.entries(): strataDependencyGraph.put(ImmutableSet.of(entry.getKey()), ImmutableSet.of(entry.getValue())) return strataDependencyGraph
def createWithProver(cls, model): """ generated source for method createWithProver """ sentencesByForm = HashMultimap.create() addSentencesTrueByRules(sentencesByForm, model) return ImmutableConstantChecker.create(model, sentencesByForm)