public ICollection <Literal> getTail()
{
if (0 == literals.Size())
{
return(_emptyLiteralsList);
}
return(CollectionFactory.CreateReadOnlyQueue <Literal>(literals.subList(1, literals.Size())));
}
public ICollection <IAction> apply(VacuumEnvironmentState state)
{
ICollection <IAction> actions = CollectionFactory.CreateQueue <IAction>();
actions.Add(VacuumEnvironment.ACTION_SUCK);
actions.Add(VacuumEnvironment.ACTION_MOVE_LEFT);
actions.Add(VacuumEnvironment.ACTION_MOVE_RIGHT);
// Ensure cannot be modified.
return(CollectionFactory.CreateReadOnlyQueue <IAction>(actions));
}
ICollection <FOLNode> FOLNode.getArgs()
{
ICollection <FOLNode> obj = CollectionFactory.CreateQueue <FOLNode>();
foreach (Sentence sentence in args)
{
obj.Add(sentence);
}
return(CollectionFactory.CreateReadOnlyQueue <FOLNode>(obj));
}
ICollection <FOLNode> FOLNode.getArgs()
{
ICollection <FOLNode> obj = CollectionFactory.CreateQueue <FOLNode>();
foreach (Term term in getTerms())
{
obj.Add(term);
}
return(CollectionFactory.CreateReadOnlyQueue <FOLNode>(obj));
}
public BayesNet(params INode[] rootNodes)
{
if (null == rootNodes)
{
throw new IllegalArgumentException("Root Nodes need to be specified.");
}
foreach (INode n in rootNodes)
{
this.rootNodes.Add(n);
}
if (this.rootNodes.Size() != rootNodes.Length)
{
throw new IllegalArgumentException("Duplicate Root Nodes Passed in.");
}
// Ensure is a DAG
checkIsDAGAndCollectVariablesInTopologicalOrder();
variables = CollectionFactory.CreateReadOnlyQueue <IRandomVariable>(variables);
}
public ICollection <Term> getTerms()
{
return(CollectionFactory.CreateReadOnlyQueue <Term>(terms));
}
public ICollection <Sentence> getArgs()
{
return(CollectionFactory.CreateReadOnlyQueue <Sentence>(args));
}
public ICollection <FOLNode> getArgs()
{
return(CollectionFactory.CreateReadOnlyQueue <FOLNode>(args));
}
public ICollection <Variable> getVariables()
{
return(CollectionFactory.CreateReadOnlyQueue <Variable>(variables));
}
public virtual ICollection <IEnvironmentObject> GetEnvironmentObjects()
{
// Return as a List but also ensures the caller cannot modify
return(CollectionFactory.CreateReadOnlyQueue <IEnvironmentObject>(envObjects));
}
public ICollection <Clause> getConjunctionOfClauses()
{
return(CollectionFactory.CreateReadOnlyQueue <Clause>(conjunctionOfClauses));
}
public ICollection <Literal> getLiterals()
{
return(CollectionFactory.CreateReadOnlyQueue <Literal>(literals));
}
public ICollection <Clause> getAllDefiniteClauseImplications()
{
return(CollectionFactory.CreateReadOnlyQueue <Clause>(implicationDefiniteClauses));
}
public ICollection <Sentence> getOriginalSentences()
{
return(CollectionFactory.CreateReadOnlyQueue <Sentence>(originalSentences));
}
private int descendants; // for debugging!
/**
* Construct an individual using the provided representation.
*
* @param representation
* the individual's representation.
*/
public Individual(ICollection <A> representation)
{
this.representation = CollectionFactory.CreateReadOnlyQueue <A>(representation);
}
public override ICollection <ProofStep> getPredecessorSteps()
{
return(CollectionFactory.CreateReadOnlyQueue <ProofStep>(predecessors));
}
public virtual ICollection <IAgent> GetAgents()
{
// Return as a List but also ensures the caller cannot modify
return(CollectionFactory.CreateReadOnlyQueue <IAgent>(agents));
}
