public List <GameMoveResult> MakeMoves(object owner, IContextLookup globalVars, int movesNumber)
{
var objGame = Game.EvaluateTyped(owner, globalVars);
var objState = State.Evaluate(owner, globalVars);
var objStrategy = Strategy.GetValue(owner, globalVars);
return(objStrategy.MakeMoves(objGame, objState, movesNumber));
}
internal DefaultPropertyBuildContext(ILookup innerLookup, IContextLookup contextLookup, IPropertyMap map, TSubject subject)
{
this.innerLookup = innerLookup;
this.contextLookup = contextLookup;
this.map = map;
this.getInstance = delegate() { return(subject); };
this.setInstance = delegate { };
}
public bool Ask(object owner, IContextLookup globalVars)
{
var kb = KnowledgeBase.EvaluateTyped(owner, globalVars);
var predicate = Predicate.GetValue(owner, globalVars);
var objInferProc = Procedure.EvaluateTyped(owner, globalVars);
return(objInferProc.Ask(kb, predicate));
}
public CategoricalDistribution AskBayesianModel(object owner, IContextLookup globalVars)
{
var randomVariables = BayesianNetwork.GetRandomVariables(owner, globalVars);
var network = BayesianNetwork.GetNetwork(randomVariables);
var inference = InferenceType.GetInference();
var model = new FiniteBayesModel(network, inference);
return(Ask.AskBayesianModel(owner, globalVars, randomVariables, model));
}
protected DefaultPropertyBuildContext(ILookup innerLookup, IContextLookup contextLookup, string prefix, IPropertyMap map, GetInstanceDelegate <TSubject> getInstance, SetInstanceDelegate <TSubject> setInstance, AssignmentPolicy policy)
{
this.innerLookup = innerLookup;
this.map = map;
this.prefix = prefix;
this.getInstance = getInstance;
this.setInstance = setInstance;
this.policy = policy;
this.contextLookup = contextLookup;
}
public GameMoveResult MakeMove(object owner, IContextLookup globalVars)
{
var moves = MakeMoves(owner, globalVars, 1);
if (moves.Count > 0)
{
return(moves[0]);
}
return(null);
}
public BackPropagation GetLearningMethod(object owner, IContextLookup globalVars, BasicNetwork theNetwork,
IList <BasicData> data)
{
double theLearningRate = LearningRate.GetValue(owner, globalVars);
double theMomentum = Momentum.GetValue(owner, globalVars);
var theL1 = L1.GetValue(owner, globalVars);
var theL2 = L2.GetValue(owner, globalVars);
var toReturn = new BackPropagation(theNetwork, data, theLearningRate, theMomentum);
toReturn.L1 = theL1;
toReturn.L2 = theL2;
return(toReturn);
}
public Assignment SolveCSP(object owner, IContextLookup globalVars)
{
var objStrategy = Strategy.EvaluateTyped(owner, globalVars);
var objListeners = StateListeners.EvaluateGeneric(owner, globalVars);
foreach (KeyValuePair <string, CSPStateListener> keyValuePairListener in objListeners)
{
objStrategy.addCSPStateListener(keyValuePairListener.Value);
globalVars.Items[keyValuePairListener.Key] = keyValuePairListener.Value;
}
var objCSP = CSP.EvaluateTyped(owner, globalVars);
return(objStrategy.solve(objCSP));
}
public object Train(object owner, IContextLookup globalVars)
{
object theNetwork = Network.EvaluateTyped(owner, globalVars);
IEnumerable theData = Data.EvaluateTyped(owner, globalVars);
ILearningMethodInfo theLearningMethodInfo = LearningMethod.EvaluateTyped(owner, globalVars);
ILearningMethod learningMethod = theLearningMethodInfo.GetLearningMethod(owner, globalVars, theNetwork,
theData);
IEnumerable theValidationData = ValidationData.EvaluateTyped(owner, globalVars);
ITrainingInfo theTrainMode = TrainMode.EvaluateTyped(owner, globalVars);
theTrainMode.PerformTraining(learningMethod, theNetwork, theValidationData);
return(theNetwork);
}
public HiddenMarkovModel GetModel(object owner, IContextLookup globalVars)
{
var randomVar = StateVariable.GetRandomVariable(owner, globalVars);
var transition = TransitionModel.GetMatrix();
var sensor = new HashMap();
foreach (SensorMapRowInfo row in SensorModel)
{
var value = row.Value.Evaluate(owner, globalVars);
var distribution = row.SensorModel.GetMatrix();
sensor.put(value, distribution);
}
var objPrior = Prior.GetMatrix();
return(new HMM(randomVar, transition, sensor, objPrior));
}
public IDictionary <string, RandomVariable> GetRandomVariables(object owner, IContextLookup globalVars, IDictionary <string, RandomVariable> existingVars)
{
IDictionary <string, RandomVariable> randomVars = existingVars;
if (randomVars == null)
{
randomVars = new Dictionary <string, RandomVariable>(RandomVariables.Count);
}
foreach (RandomVariableInfo randomVariableInfo in RandomVariables)
{
if (!randomVars.ContainsKey(randomVariableInfo.Name))
{
randomVars[randomVariableInfo.Name] = randomVariableInfo.GetRandomVariable(owner, globalVars);
}
}
return(randomVars);
}
public Problem GetProblem(Object owner, IContextLookup globalVars, Object initialState)
{
Problem toReturn;
var objActionsFunction = ActionsFunction.EvaluateTyped(owner, globalVars);
var objResultFunction = ResultFunction.EvaluateTyped(owner, globalVars);
var objGoalTest = GoalTest.EvaluateTyped(owner, globalVars);
if (StepCostFunction.Enabled)
{
var objStepCostFunction = StepCostFunction.Entity.EvaluateTyped(owner, globalVars);
toReturn = new Problem(initialState, objActionsFunction, objResultFunction, objGoalTest, objStepCostFunction);
}
else
{
toReturn = new Problem(initialState, objActionsFunction, objResultFunction, objGoalTest);
}
return(toReturn);
}
public SearchAgentResult PerformSearch(object owner, IContextLookup globalVars)
{
var objInitialState = InitialState.Evaluate(owner, globalVars);
var objProblemInfo = Problem.GetValue(owner, globalVars);
var objSearchInfo = Search.GetValue(owner, globalVars);
Problem objProblem = objProblemInfo.GetProblem(owner, globalVars, objInitialState);
var objHeuristicFunction = HeuristicFunction.Entity.EvaluateTyped(owner, globalVars);
if (objHeuristicFunction == null)
{
objHeuristicFunction = DefaultHeuristics;
}
var objSearch = objSearchInfo.GetSearch(owner, globalVars, objHeuristicFunction);
return(new SearchAgentResult()
{
Problem = objProblem, SearchAgent = new SearchAgent(objProblem, objSearch)
});
}
public CategoricalDistribution AskBayesianModel(object owner, IContextLookup globalVars, IDictionary <string, RandomVariable> randomVariables, FiniteProbabilityModel model)
{
var priorProps = Prior.Select(objProp => objProp.GetProposition(owner, globalVars, randomVariables));
switch (QueryType)
{
case BayesianQueryType.Prior:
return(model.priorDistribution(priorProps.ToArray()));
case BayesianQueryType.Posterior:
var posteriorProps = Posteriors.Select(objProp => objProp.GetProposition(owner, globalVars, randomVariables));
return(model.posteriorDistribution(priorProps.ToArray()[0], posteriorProps.ToArray()));
case BayesianQueryType.Joint:
return(model.jointDistribution((priorProps.ToArray())));
default:
throw new ArgumentOutOfRangeException();
}
}
public List <AssignmentProposition[][]> AskParticleFiltering(object owner, IContextLookup globalVars)
{
var randomVars = DynamicBayesianNetwork.GetRandomVariables(owner, globalVars);
var model = DynamicBayesianNetwork.GetNetwork(randomVars);
Randomizer objRandomizer;
switch (RandomizerType)
{
case RandomizerType.Random:
objRandomizer = new JavaRandomizer();
break;
case RandomizerType.Mock:
objRandomizer = new MockRandomizer(RandomizerValues.ToArray());
break;
default:
throw new ArgumentOutOfRangeException();
}
var objAlgorithm = new ParticleFiltering(SampleNb, (DynamicBayesianNetwork)model, objRandomizer);
var objEvidences = new java.util.ArrayList(Evidences.Count);
var toReturn = new List <AssignmentProposition[][]>();
foreach (List <PropositionInfo> propositions in Evidences)
{
var stepEvidences = new List <AssignmentProposition>(propositions.Count);
foreach (PropositionInfo proposition in propositions)
{
stepEvidences.Add((AssignmentProposition)proposition.GetProposition(owner, globalVars, randomVars));
}
toReturn.Add(objAlgorithm.particleFiltering(stepEvidences.Cast <AssignmentProposition>().ToArray()));
}
return(toReturn);
}
public IDictionary <string, RandomVariable> GetRandomVariables(object owner, IContextLookup globalVars)
{
return(GetRandomVariables(owner, globalVars, null));
}
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars)
{
return(DoForwardBackward(owner, globalVars));
}
public aima.core.search.framework.Search GetSearch(Object owner, IContextLookup globalVars, HeuristicFunction objHeuristicFunction)
{
aima.core.search.framework.Search toReturn;
QueueSearch objQueueSearch;
switch (QueueSearchType)
{
case QueueSearchType.TreeSearch:
objQueueSearch = new TreeSearch();
break;
default:
objQueueSearch = new GraphSearch();
break;
}
switch (AlgorithmType)
{
case SearchAlgorithmType.KnownInformed:
switch (KnownInformedAlgorithm)
{
case KnownInformedSearch.GreedyBestFirst:
toReturn = new GreedyBestFirstSearch(objQueueSearch, objHeuristicFunction);
break;
case KnownInformedSearch.RecursiveGreedyBestFirst:
toReturn = new RecursiveBestFirstSearch(new GreedyBestFirstEvaluationFunction(objHeuristicFunction));
break;
case KnownInformedSearch.RecursiveAStar:
toReturn = new RecursiveBestFirstSearch(new AStarEvaluationFunction(objHeuristicFunction));
break;
case KnownInformedSearch.HillClimbing:
toReturn = new HillClimbingSearch(objHeuristicFunction);
break;
case KnownInformedSearch.SimulatedAnnealing:
toReturn = new SimulatedAnnealingSearch(objHeuristicFunction);
break;
default:
toReturn = new AStarSearch(objQueueSearch, objHeuristicFunction);
break;
}
break;
case SearchAlgorithmType.KnownUninformed:
switch (KnownUninformedAlgorithm)
{
case KnownUninformedSearch.DepthFirst:
toReturn = new DepthFirstSearch(objQueueSearch);
break;
case KnownUninformedSearch.DepthLimited:
toReturn = new DepthLimitedSearch(DepthLimit);
break;
case KnownUninformedSearch.IterativeDeepening:
toReturn = new IterativeDeepeningSearch();
break;
case KnownUninformedSearch.UniformCost:
toReturn = new UniformCostSearch(objQueueSearch);
break;
case KnownUninformedSearch.Bidirectional:
toReturn = new BidirectionalSearch();
break;
default:
toReturn = new BreadthFirstSearch(objQueueSearch);
break;
}
break;
default:
toReturn = CustomSearchAlgorithm.EvaluateTyped(owner, globalVars);
break;
}
return(toReturn);
}
public void Query(object owner, IContextLookup globalVars)
{
object theNetwork = Network.EvaluateTyped(owner, globalVars);
IEnumerable theData = Data.EvaluateTyped(owner, globalVars);
}
private void Init(object owner, IContextLookup globalVars, DynamicCSP objCSP)
{
var objVariables = Variables.EvaluateTyped(owner, globalVars);
var dicoVariables = (from object objVariable in objVariables select ReflectionHelper.GetFriendlyName(objVariable)).ToDictionary(varName => varName, varName => new Variable(varName));
foreach (var objVariable in dicoVariables.Values)
{
objCSP.AddNewVariable(objVariable);
}
var objDomains = Domains.EvaluateGeneric(owner, globalVars);
var dicoDomains = new Dictionary <string, Domain>();
foreach (KeyValuePair <string, IEnumerable> keyValuePair in objDomains)
{
var domainArray = new ArrayList();
foreach (object domainItem in keyValuePair.Value)
{
domainArray.Add(domainItem);
}
Domain domain = new Domain(domainArray.ToArray());
dicoDomains.Add(keyValuePair.Key, domain);
}
if (dicoDomains.Count == 0)
{
throw new ApplicationException("No Domain defined for CSP problem");
}
if (dicoDomains.Count == 1)
{
var domain = dicoDomains.Values.First();
Iterator terator = objCSP.getVariables().iterator();
while (terator.hasNext())
{
objCSP.setDomain((Variable)terator.next(), domain);
}
}
else
{
var varDomains = VariableDomains.GetValue(owner, globalVars);
foreach (KeyValuePair <string, Variable> varPair in dicoVariables)
{
string targetDomain;
Domain objDomain;
if (varDomains.TryGetValue(varPair.Key, out targetDomain) &&
dicoDomains.TryGetValue(targetDomain, out objDomain))
{
objCSP.setDomain(varPair.Value, objDomain);
}
else
{
throw new ApplicationException("Incomplete Variables Domain affectation");
}
}
}
var objConstraints = Constraints.EvaluateTyped(owner, globalVars);
foreach (Constraint objConstraint in objConstraints)
{
objCSP.addConstraint(objConstraint);
}
}
public ILearningMethod GetLearningMethod(object owner, IContextLookup globalVars, object theNetwork,
IEnumerable data)
{
return(GetLearningMethod(owner, globalVars, (BasicNetwork)theNetwork, (IList <BasicData>)data));
}
public void SetNext(IContextLookup next)
{
this.next = next;
}
/// <summary>
/// Populates this instance from scratch using a provided selection provider.
/// </summary>
/// <remarks>This instance will be cleared, and all constraints on it will be reset.
/// The builder inspects the first <see cref="IPropertyItemDescriptor{T}"/> from
/// <paramref name="selectionProvider"/> and creates an <see cref="IOptionBuilder"/> instance
/// that will <see cref="IOptionBuilder.AddItems"/> to this instance via the builder.
/// </remarks>
/// <param name="selectionProvider"></param>
/// <param name="contextLookup">The lookup tunnel through to the created
/// <see cref="IOptionBuilderContext"/> that will be used to query the <see cref="IOptionBuilder"/>
/// instances for recursive sets of properties.</param>
public virtual void BuildFromSelection <T>(ISelectionProvider <T> selectionProvider, IContextLookup contextLookup)
{
StartContentChange();
try {
Clear();
DefaultOptionBuilderContext <T> context;
context = new DefaultOptionBuilderContext <T>(selectionProvider, this);
context.ContextLookup = contextLookup;
ConstraintManager constraintManager = this.Lookup <ConstraintManager>();
if (constraintManager == null)
{
constraintManager = new ConstraintManager(this);
this.SetLookup(typeof(ConstraintManager), constraintManager);
}
constraintManager.Clear();
IEnumerator <IPropertyItemDescriptor <T> > enumerator = selectionProvider.Selection.GetEnumerator();
if (enumerator.MoveNext())
{
IPropertyItemDescriptor <T> descriptor = enumerator.Current;
T item;
item = descriptor.Item;
IOptionBuilder builder = context.GetOptionBuilder(item);
if (builder != null)
{
builder.AddItems(context, item.GetType(), item);
}
}
} finally {
EndContentChange();
}
}
public abstract List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars);
internal DecoratedBuildContext(ILookup lookup, IContextLookup innerLookup, string prefix, IPropertyMap map, GetInstanceDelegate <TInnerSubject> getHandler, SetInstanceDelegate <TInnerSubject> setHandler, AssignmentPolicy policy)
: base(lookup, innerLookup, prefix, map, getHandler, setHandler, policy)
{
}
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars)
{
throw new NotImplementedException();
}
public override List <CategoricalDistribution> Ask(object owner, IContextLookup globalVars)
{
return(AskFixedLagSmoothing(owner, globalVars));
}
