import com.sri.ai.util.Util; //导入依赖的package包/类
public void updateSetsOfFactorsAndVariables() {
	if (this.node.isFactor()) {
		FactorNode newFactor = (FactorNode) this.node;
		Set<VariableNode> newVariables = new HashSet<VariableNode>();
		// Util.println(model);
		if (this.model==null) {
			this.model=this.parent.model;
		}
		Util.println(this.model);
		newVariables.addAll(this.model.getExploredGraph().getAsOfB(newFactor));// we look at the variables involved in the factor
		newVariables.remove(this.parent.node.getValue());// we remove the parent, which is already in the variable set
		this.updateSetsOfFactorsAndVariables(newFactor, newVariables);
	} else{
		this.updateSetsOfVariables();
	}
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
/**
 * Gets a function application and its type <code>T</code>, and returns the inferred type of its functor,
 * which is <code>'->'('x'(T1, ..., Tn), T)</code>, where <code>T1,...,Tn</code> are the types.
 */
public static Expression getTypeOfFunctor(Expression functionApplication, Expression functionApplicationType, Registry registry) {
	Expression result;
	if (functionApplication.getSyntacticFormType().equals(FunctionApplication.SYNTACTIC_FORM_TYPE)) {
		List<Expression> argumentTypes = Util.mapIntoArrayList(functionApplication.getArguments(), new GetType(registry));
		if (argumentTypes.contains(null)) {
			result = null; // unknown type
		}
		else {
			result = FunctionType.make(functionApplicationType, argumentTypes);
		}
	}
	else {
		throw new Error("getTypeOfFunctor applicable to function applications only, but invoked on " + functionApplication);
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
public static void main(String[] args) {
	plot(
			Util.list( // precommands
					"persist",
					//"set term postscript color",
					//"set output 'test.ps'",
					"set xlabel 'Time'",
					"set ylabel 'Intensity'"
			),
			Util.getIteratorNullaryFunction(Util.list(10,20,30,40)), // xSeries
			Util.list( // list of ySeries
					new DataSeries<Integer>(
							Util.list("title 'random sequence 1'", "w linespoints"),
							Util.list(1,2,4,3)
							),
					new DataSeries<Integer>(
							Util.list("title 'random sequence 2'", "w linespoints"),
							Util.list(5,4,3,2)
							)
					)
			);
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Override
protected void translate(String inputIdentifier, Reader[] inputModelReaders, PrintWriter[] translatedOutputs) throws Exception {	
	//
	// 1. Get the HOGM Model Definition and Parse It
	String hogmv1Model = Util.readAll(inputModelReaders[0]);
	HOGMParserWrapper parser          = new HOGMParserWrapper();
	ParsedHOGModel    parsedModel     = parser.parseModel(hogmv1Model);
	FactorsAndTypes   factorsAndTypes = new ExpressionFactorsAndTypes(parsedModel);
	
	// Each additional input is treated as an evidence expression
	List<Expression> evidence = new ArrayList<>();
	if (inputModelReaders.length > 1) {
		for (int i = 1; i < inputModelReaders.length; i++) {
			evidence.add(Expressions.parse(Util.readAll(inputModelReaders[i])));
		}
	}
	
	translate(inputIdentifier, factorsAndTypes, evidence, translatedOutputs);
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Test
public void testCastOrThrowError() {
	Integer i = 10;
	Object iObject = i;
	Integer j = Util.castOrThrowError(Integer.class, iObject, "Got %s, which should have been an instance of %s but is instead an instance of %s");
	Assert.assertEquals(i, j);

	try {
		Util.castOrThrowError(String.class, iObject, "Got %s, which should have been an instance of %s but is instead an instance of %s");
	} catch (Error e) {
		Assert.assertEquals("Got 10, which should have been an instance of String but is instead an instance of Integer", e.getMessage());
		return;
	}
	
	Assert.fail("Util.castOrThrowError should have throw error when attempting to cast Integer into String but did not.");
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Override
public Expression applySimplifier(Expression expression, Context context) {
	// We need to override this method because INFINITY and MINUS_INFINITY
	// are not Java constants.
	Expression result;
	if ( ! isExtensional(expression)) {
		result = expression;
	}
	else {
		// takes care of infinity arguments before deferring to super method
		if (expression.getArguments().contains(INFINITY)) {
			result = INFINITY;
		}
		else {
			// remove MINUS_INFINITY if any and defer to super method
			List<Expression> argumentsWithoutMinusInfinity =
					Util.removeNonDestructively(expression.getArguments(), MINUS_INFINITY);
			Expression expressionWithoutMinusInfinity =
					expression.getArguments() == argumentsWithoutMinusInfinity?
							expression : Expressions.apply(expression.getFunctor(), argumentsWithoutMinusInfinity);
			result = super.apply(expressionWithoutMinusInfinity, context);
		}
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
public static Expression simplify(Expression disjunction) {
	Expression result = disjunction;
	if (disjunction.getArguments().contains(Expressions.TRUE)) {
		result = Expressions.TRUE;
	}
	else {
		LinkedHashSet<Expression> distinctArgumentsNotEqualToFalse = new LinkedHashSet<Expression>();
		Util.collect(disjunction.getArguments(), distinctArgumentsNotEqualToFalse, e -> ! e.equals(Expressions.FALSE));
		if (distinctArgumentsNotEqualToFalse.size() != disjunction.getArguments().size()) {
			if (distinctArgumentsNotEqualToFalse.size() == 0) {
				result = Expressions.FALSE;
			}
			else if (distinctArgumentsNotEqualToFalse.size() == 1) {
				result = Util.getFirst(distinctArgumentsNotEqualToFalse);
			}
			else if (distinctArgumentsNotEqualToFalse.size() != disjunction.numberOfArguments()) {
				result = Expressions.apply(FunctorConstants.OR, distinctArgumentsNotEqualToFalse);
			}
		}
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
public static Expression simplify(Expression conjunction) {
	Expression result = conjunction;
	if (conjunction.getArguments().contains(Expressions.FALSE)) {
		result = Expressions.FALSE;
	}
	else {
		LinkedHashSet<Expression> distinctArgumentsNotEqualToTrue = new LinkedHashSet<Expression>();
		Util.collect(conjunction.getArguments(), distinctArgumentsNotEqualToTrue, e -> ! e.equals(Expressions.TRUE));
		if (distinctArgumentsNotEqualToTrue.size() != conjunction.getArguments().size()) {
			if (distinctArgumentsNotEqualToTrue.size() == 0) {
				result = Expressions.TRUE;
			}
			else if (distinctArgumentsNotEqualToTrue.size() == 1) {
				result = Util.getFirst(distinctArgumentsNotEqualToTrue);
			}
			else if (distinctArgumentsNotEqualToTrue.size() != conjunction.numberOfArguments()) {
				result = Expressions.apply(FunctorConstants.AND, distinctArgumentsNotEqualToTrue);
			}
		}
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Override
protected T refineOrNull() {
	
	T result = null;
	
	if ( ! firstComputationDone) { // first computed value
		result = computeFunction();
		firstComputationDone = true;
	}
	else { // incremental computation
		boolean hasMoreRefinedValue;
		if ( ! (hasMoreRefinedValue = Util.thereExists(arguments, new HasMoreRefinedValueSinceLastTimeAtNoCost()))) {
			hasMoreRefinedValue = tryToRefineSomeArgumentAccordingToRanking();
		}
		if (hasMoreRefinedValue) {
			result = computeFunction();
		}
	}

	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Test
public void testSubRangeIterator() {
	SubRangeIterator<String> i;
	List<String> expected;

	i =
		new SubRangeIterator<String>(
				Util.iterator("a", "b", "c"),
				1, 3);
	expected = Util.list("b", "c");
	assertEquals(expected, Util.listFrom(i));

	i =
		new SubRangeIterator<String>(
				Util.iterator("a", "b", "c"),
				0, 0);
	expected = Collections.emptyList();
	assertEquals(expected, Util.listFrom(i));

	i =
		new SubRangeIterator<String>(
				Util.iterator("a", "b", "c"),
				0, 4);
	expected = Util.list("a", "b", "c");
	assertEquals(expected, Util.listFrom(i));
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
/**
 * Returns TRUE if given equality has all-equal arguments, FALSE if they contain distinct constants,
 * and the equality itself otherwise.
 * Note that this is much faster than eliminating duplicates as well, which requires constructing another equality.
 */
public static Expression simplify(Expression equality, Context context) {
	Expression result;
	if (Util.allEqual(equality.getArguments())) {
		result = Expressions.TRUE;
	}
	else {
		Set<Expression> constants = new LinkedHashSet<Expression>();
		Set<Expression> nonConstants = new LinkedHashSet<Expression>();
		Util.collect(equality.getArguments(), constants, context.getIsUniquelyNamedConstantPredicate(), nonConstants);
		if (constants.size() > 1) {
			result = Expressions.FALSE;
		}
		else if (constants.size() == 1 && constants.contains(Expressions.TRUE)) {
			result = And.make(new ArrayList<Expression>(nonConstants));
		}
		else if (constants.size() == 1 && constants.contains(Expressions.FALSE)) {
			ArrayList<Expression> negatedNonConstants = Util.mapIntoArrayList(nonConstants, e -> Not.make(e));
			result = And.make(new ArrayList<Expression>(negatedNonConstants));
		}
		else {
			result = equality;
		}
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public boolean put(Iterator path) {
	boolean result = false;
	if (path.hasNext()) {
		Object nextKey = path.next();
		result = result || !containsKey(nextKey);
		HashMapRandomAccessTree subTree = (HashMapRandomAccessTree) Util
				.getValuePossiblyCreatingIt(this, nextKey,
						HashMapRandomAccessTree.class);
		boolean subResult = subTree.put(path);
		return result || subResult;
	} 
	else {
		valid = true; // indicates that path ending here is valid.
	}
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
public UnificationStepSolver(Expression expression1, Expression expression2) {
	if (expression1.equals(expression2)) { // Check for simple literal equality up front.
		precomputedResult = new StepSolver.Solution<Boolean>(Boolean.TRUE);
	}
	else if (Expressions.isFunctionApplicationWithArguments(expression1) &&
			 Expressions.isFunctionApplicationWithArguments(expression2) &&
			 expression1.numberOfArguments() == expression2.numberOfArguments() &&
			 expression1.getFunctor().equals(expression2.getFunctor())) {
		unificationEqualitiesToTest = Util.zipWith(
				(matchingArgFrom1, matchingArgFrom2) -> Equality.make(matchingArgFrom1, matchingArgFrom2),
				expression1.getArguments(), expression2.getArguments());
	}
	else if (Expressions.isSymbol(expression1) && Expressions.isSymbol(expression2)) {
		unificationEqualitiesToTest = Arrays.asList(Equality.make(expression1, expression2));
	}
	else {
		precomputedResult = new StepSolver.Solution<Boolean>(Boolean.FALSE);
	}
	
	if (unificationEqualitiesToTest != null) {
		unknownSolutionIndexesForUnificationEqualities = 
				IntStream.range(0, unificationEqualitiesToTest.size())
					.boxed()
					.collect(Collectors.toList());
	}
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
private static Map<Expression, Expression> createTuplesOfVarsForTupleTypes(QuantifiedExpression quantifiedExpression, List<Map.Entry<Expression, Expression>> indexesOfTupleType) {
	Map<Expression, Expression> result = new HashMap<>();
	
	Set<Expression> allSubExpressions = Util.addAllToSet(new SubExpressionsDepthFirstIterator(quantifiedExpression));
	for (Map.Entry<Expression, Expression> entry : indexesOfTupleType) {
		List<Expression> tupleVars = new ArrayList<>();
		for (int i = 1; i <= entry.getValue().numberOfArguments(); i++) {
			Expression proposedVar = Expressions.makeSymbol(entry.getKey().toString()+"_"+i);
			Expression actualVar   = Expressions.primedUntilUnique(proposedVar, expr -> !allSubExpressions.contains(expr));
			tupleVars.add(actualVar);
		}
		result.put(entry.getKey(), Expressions.makeTuple(tupleVars));
	}
	
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
protected ArrayList<PairOf<Expression>> pairsOfEquals() {
	if (pairsOfEquals == null) {
		ArrayList<Expression> equalities = Util.collectToArrayList(getConstraint().getPositiveNormalizedAtoms(), e -> e.hasFunctor(EQUALITY));

		PairOfElementsInListIterator<Expression> pairsOfEqualitiesIterator = 
				new PairOfElementsInListIterator<>(equalities);

		//		Function<PairOf<Expression>, PairOf<Expression>> makePairOfSecondArguments = p -> makePairOf(p.first.get(1), p.second.get(1));
		// above lambda somehow not working at Ciaran's environment, replacing with seemingly identical anonymous class object below		
		Function<PairOf<Expression>, PairOf<Expression>> makePairOfSecondArguments = new Function<PairOf<Expression>, PairOf<Expression>>() {
			@Override
			public PairOf<Expression> apply(PairOf<Expression> p) {
				return makePairOf(p.first.get(1), p.second.get(1));
			}
		};
		Iterator<PairOf<Expression>> pairsOfEqualsIterator = functionIterator(pairsOfEqualitiesIterator, makePairOfSecondArguments);
		
		pairsOfEquals = arrayListFrom(pairsOfEqualsIterator);
	}

	return pairsOfEquals;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
private static Integer pickMinimal(List<FactorTable> factors) {		
	if (factors.size() == 0) {
		throw new IllegalArgumentException("Need > 0 factors to pick a minimum");
	}
	
	Map<Integer, Set<Integer>> randomVariableNeighbors = new LinkedHashMap<>();
	
	for (FactorTable factor : factors) {
		for (Integer rv : factor.getVariableIndexes()) {
			Set<Integer> neighbors = Util.getValuePossiblyCreatingIt(randomVariableNeighbors, rv, LinkedHashSet.class);
			neighbors.addAll(factor.getVariableIndexes()); // NOTE: include self for efficiency as all counts will end up being + 1
		}
	}
	
	Map.Entry<Integer, Set<Integer>> smallestEntry = randomVariableNeighbors.entrySet().stream()
				.min((e1, e2) -> Integer.compare(e1.getValue().size(), e2.getValue().size())).get();

	if (smallestEntry.getValue().size() > MAX_NUM_ALLOWED_PARENTS_IN_CPT) {			
		throw new IllegalStateException("Too large a CPT will need be generated as #parents="+(smallestEntry.getValue().size()-1));
	}	
	
	Integer result = smallestEntry.getKey();		
	
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
@Override
public Expression replace(Expression expression, Expression newSubExpression) {
	AbstractQuantifiedExpression quantifiedExpression = castOrThrowError(AbstractQuantifiedExpression.class, expression, "Attempt to use " + IndexExpressionTypeSubExpressionAddress.class.getSimpleName() + " to replace sub-expression " + newSubExpression + " in %s, but the latter should have been an instance of %s but is instead an instance of %s");
	Util.myAssert(() -> quantifiedExpression.getIndexExpressions() instanceof ExtensionalIndexExpressionsSet, () -> quantifiedExpression.getClass().getSimpleName() + ".replaceIndexExpression assumes extensional set of index expressions but " + quantifiedExpression + " has a non-extensional index expression set");

	List<Expression> indexExpressionsList = ((ExtensionalIndexExpressionsSet) quantifiedExpression.getIndexExpressions()).getList();
	List<Expression> newIndexExpressionsList =
			replaceElementNonDestructively(indexExpressionsList, indexExpressionIndex,
					ie -> replaceAddressedSubExpressionInIndexExpressionByNewSubExpression(ie, newSubExpression));

	Expression result;
	if (newIndexExpressionsList != indexExpressionsList) {
		IndexExpressionsSet newIndexExpressions = new ExtensionalIndexExpressionsSet(newIndexExpressionsList);
		result = quantifiedExpression.setIndexExpressions(newIndexExpressions);
	}
	else {
		result = quantifiedExpression;
	}
	
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
private void regular() {
	try {
		myAssert(() -> true,  () -> "error message 1");
		myAssert(() -> false, () -> "error message 2");
		if (System.getProperty(Util.MY_ASSERT_OFF) == null) {
			fail("Should have thrown an AssertionError but did not. System.getProperty(Util.MY_ASSERT_OFF) = " + System.getProperty(Util.MY_ASSERT_OFF));
		}
	}
	catch (AssertionError error) {
		if (error.getMessage().equals("error message 2")) {
			if (System.getProperty(Util.MY_ASSERT_OFF) == null) {
				// good, passed the unit test
			}
			else {
				fail("Threw assertion error when it should not have.");
			}
		}
		else {
			fail("Threw the wrong assertion error.");
		}
	}
	// good, passed the unit test
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
protected Expression makeIntensionalSet(Object label, Token scope, List<AntlrGrinderParser.ExprContext> scopeargs, 
		AntlrGrinderParser.ExprContext head, AntlrGrinderParser.ExprContext condition) {
	List<Expression> indexExpressionsList = Util.list();
	if (scope != null) {
		indexExpressionsList = expressionsList(scopeargs);
	}
	Expression headExpression      = visit(head);
	Expression conditionExpression = null;
	if (condition != null) {
		conditionExpression = Expressions.makeExpressionOnSyntaxTreeWithLabelAndSubTrees(IntensionalSet.CONDITION_LABEL, visit(condition));
	}

	Expression result = null;
	if (scope == null && conditionExpression == null) {
		// We need to construct an extensional set in this case
		if (label.equals(IntensionalSet.UNI_SET_LABEL)) {
			result = ExtensionalSets.makeUniSet(headExpression);
		}
		else {
			result = ExtensionalSets.makeMultiSet(Arrays.asList(headExpression));
		}
	}
	else {
		conditionExpression = conditionExpression == null? Expressions.TRUE : conditionExpression.get(0); // contains the "|";
		result = IntensionalSet.make(label, new ExtensionalIndexExpressionsSet(indexExpressionsList), headExpression, conditionExpression);
	}
	
	return result;
}
 

import com.sri.ai.util.Util; //导入依赖的package包/类
/**
 * Convenience for <code>this.getTheory().isLiteral(expression, this)</code>.
 * @param expression
 * @return
 */
default boolean isLiteral(Expression expression) {
	Theory theory = getTheory();
	Util.myAssert(theory != null, () -> "Context does not contain a theory, but is trying to check if " + expression + " is a literal according to some theory. Please make sure the context has been provided a theory");
	boolean result = theory.isLiteralOrBooleanConstant(expression, this);
	return result;
}