/// <summary>
        /// Executes agent innovation process for specific site
        /// </summary>
        /// <param name="agent">The agent.</param>
        /// <param name="lastIteration">The last iteration.</param>
        /// <param name="goal">The goal.</param>
        /// <param name="layer">The layer.</param>
        /// <param name="site">The site.</param>
        /// <param name="probabilities">The probabilities.</param>
        /// <exception cref="Exception">Not implemented for AnticipatedDirection == 'stay'</exception>
        public void Execute(IAgent agent, LinkedListNode <Dictionary <IAgent, AgentState <TSite> > > lastIteration, Goal goal,
                            DecisionOptionLayer layer, TSite site, Probabilities probabilities)
        {
            Dictionary <IAgent, AgentState <TSite> > currentIteration = lastIteration.Value;
            Dictionary <IAgent, AgentState <TSite> > priorIteration   = lastIteration.Previous.Value;

            //gets prior period activated decision options
            DecisionOptionsHistory history            = priorIteration[agent].DecisionOptionsHistories[site];
            DecisionOption         protDecisionOption = history.Activated.FirstOrDefault(r => r.Layer == layer);

            LinkedListNode <Dictionary <IAgent, AgentState <TSite> > > tempNode = lastIteration.Previous;

            //if prior period decision option is do nothing then looking for any do something decision option
            while (protDecisionOption == null && tempNode.Previous != null)
            {
                tempNode = tempNode.Previous;

                history = tempNode.Value[agent].DecisionOptionsHistories[site];

                protDecisionOption = history.Activated.Single(r => r.Layer == layer);
            }

            //if activated DO is missed, then select random DO
            if (!agent.AssignedDecisionOptions.Contains(protDecisionOption))
            {
                protDecisionOption = agent.AssignedDecisionOptions.Where(a => a.Layer == protDecisionOption.Layer)
                                     .RandomizeOne();
            }

            //if the layer or prior period decision option are modifiable then generate new decision option
            if (layer.LayerConfiguration.Modifiable || (!layer.LayerConfiguration.Modifiable && protDecisionOption.IsModifiable))
            {
                DecisionOptionLayerConfiguration parameters = layer.LayerConfiguration;

                Goal selectedGoal = goal;

                GoalState selectedGoalState = lastIteration.Value[agent].GoalsState[selectedGoal];

                #region Generating consequent
                int min = parameters.MinValue(agent);
                int max = parameters.MaxValue(agent);

                double consequentValue = string.IsNullOrEmpty(protDecisionOption.Consequent.VariableValue)
                    ? protDecisionOption.Consequent.Value
                    : agent[protDecisionOption.Consequent.VariableValue];

                double newConsequent = consequentValue;

                var probabilityTable =
                    probabilities.GetProbabilityTable <int>(SosielProbabilityTables.GeneralProbabilityTable);

                switch (selectedGoalState.AnticipatedDirection)
                {
                case AnticipatedDirection.Up:
                {
                    if (DecisionOptionLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Positive)
                    {
                        if (consequentValue == max)
                        {
                            return;
                        }

                        newConsequent = probabilityTable.GetRandomValue((int)consequentValue + 1, max, false);
                    }
                    if (DecisionOptionLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Negative)
                    {
                        if (consequentValue == min)
                        {
                            return;
                        }

                        newConsequent = probabilityTable.GetRandomValue(min, (int)consequentValue - 1, true);
                    }

                    break;
                }

                case AnticipatedDirection.Down:
                {
                    if (DecisionOptionLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Positive)
                    {
                        if (consequentValue == min)
                        {
                            return;
                        }

                        newConsequent = probabilityTable.GetRandomValue(min, (int)consequentValue - 1, true);
                    }
                    if (DecisionOptionLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Negative)
                    {
                        if (consequentValue == max)
                        {
                            return;
                        }

                        newConsequent = probabilityTable.GetRandomValue((int)consequentValue + 1, max, false);
                    }

                    break;
                }

                default:
                {
                    throw new Exception("Not implemented for AnticipatedDirection == 'stay'");
                }
                }

                DecisionOptionConsequent consequent = DecisionOptionConsequent.Renew(protDecisionOption.Consequent, newConsequent);
                #endregion


                #region Generating antecedent
                List <DecisionOptionAntecedentPart> antecedentList = new List <DecisionOptionAntecedentPart>(protDecisionOption.Antecedent.Length);

                bool isTopLevelDO = protDecisionOption.Layer.PositionNumber == 1;

                foreach (DecisionOptionAntecedentPart antecedent in protDecisionOption.Antecedent)
                {
                    dynamic newConst = isTopLevelDO ? antecedent.Value : agent[antecedent.Param];

                    DecisionOptionAntecedentPart newAntecedent = DecisionOptionAntecedentPart.Renew(antecedent, newConst);

                    antecedentList.Add(newAntecedent);
                }
                #endregion

                AgentState <TSite> agentState = currentIteration[agent];

                DecisionOption newDecisionOption = DecisionOption.Renew(protDecisionOption, antecedentList.ToArray(), consequent);


                //change base ai values for the new decision option
                double consequentChangeProportion;
                if (consequentValue == 0)
                {
                    consequentChangeProportion = 0;
                }
                else
                {
                    consequentChangeProportion = Math.Abs(newDecisionOption.Consequent.Value - consequentValue) / consequentValue;
                }


                Dictionary <Goal, double> baseAI = agent.AnticipationInfluence[protDecisionOption];

                Dictionary <Goal, double> proportionalAI = new Dictionary <Goal, double>();



                agent.AssignedGoals.ForEach(g =>
                {
                    double ai = baseAI[g];

                    ConsequentRelationship relationship = DecisionOptionLayerConfiguration.ConvertSign(protDecisionOption.Layer.LayerConfiguration.ConsequentRelationshipSign[g.Name]);

                    double difference = Math.Abs(ai * consequentChangeProportion);


                    switch (selectedGoalState.AnticipatedDirection)
                    {
                    case AnticipatedDirection.Up:
                        {
                            if (relationship == ConsequentRelationship.Positive)
                            {
                                ai += difference;
                            }
                            else
                            {
                                ai -= difference;
                            }

                            break;
                        }

                    case AnticipatedDirection.Down:
                        {
                            if (relationship == ConsequentRelationship.Positive)
                            {
                                ai -= difference;
                            }
                            else
                            {
                                ai += difference;
                            }

                            break;
                        }
                    }

                    proportionalAI.Add(g, ai);
                });


                //add the generated decision option to the prototype's mental model and assign one to the agent's mental model
                if (agent.Prototype.IsSimilarDecisionOptionExists(newDecisionOption) == false)
                {
                    //add to the prototype and assign to current agent
                    agent.AddDecisionOption(newDecisionOption, layer, proportionalAI);
                }
                else if (agent.AssignedDecisionOptions.Any(decisionOption => decisionOption == newDecisionOption) == false)
                {
                    var kh = agent.Prototype.DecisionOptions.FirstOrDefault(h => h == newDecisionOption);

                    //assign to current agent only
                    agent.AssignNewDecisionOption(kh, proportionalAI);
                }


                if (layer.Set.Layers.Count > 1)
                {
                    //set consequent to actor's variables for next layers
                    newDecisionOption.Apply(agent);
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Executes agent innovation process for specific site
        /// </summary>
        /// <param name="agent"></param>
        /// <param name="lastIteration"></param>
        /// <param name="goal"></param>
        /// <param name="layer"></param>
        public void Execute(IAgent agent, LinkedListNode <Dictionary <IAgent, AgentState> > lastIteration, Goal goal,
                            RuleLayer layer, ActiveSite site)
        {
            Dictionary <IAgent, AgentState> currentIteration = lastIteration.Value;
            Dictionary <IAgent, AgentState> priorIteration   = lastIteration.Previous.Value;

            //gets prior period activated rule
            RuleHistory history         = priorIteration[agent].RuleHistories[site];
            Rule        priorPeriodRule = history.Activated.Single(r => r.Layer == layer);

            LinkedListNode <Dictionary <IAgent, AgentState> > tempNode = lastIteration.Previous;

            //if prior period rule is do nothing rule then looking for any do something rule
            while (priorPeriodRule.IsAction == false && tempNode.Previous != null)
            {
                tempNode = tempNode.Previous;

                history = tempNode.Value[agent].RuleHistories[site];

                priorPeriodRule = history.Activated.Single(r => r.Layer == layer);
            }

            //if the layer or prior period rule are modifiable then generate new rule
            if (layer.LayerConfiguration.Modifiable || (!layer.LayerConfiguration.Modifiable && priorPeriodRule.IsModifiable))
            {
                RuleLayerConfiguration parameters = layer.LayerConfiguration;

                Goal selectedGoal = goal;

                GoalState selectedGoalState = lastIteration.Value[agent].GoalsState[selectedGoal];

                #region Generating consequent
                double min = parameters.MinValue(agent);
                double max = parameters.MaxValue(agent);

                double consequentValue = priorPeriodRule.Consequent.Value;

                switch (selectedGoalState.AnticipatedDirection)
                {
                case AnticipatedDirection.Up:
                {
                    if (RuleLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Positive)
                    {
                        max = Math.Abs(consequentValue - max);

                        consequentValue += (Math.Abs(PowerLawRandom.GetInstance.Next(min, max) - max));
                    }
                    if (RuleLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Negative)
                    {
                        max = Math.Abs(consequentValue - min);

                        consequentValue -= (Math.Abs(PowerLawRandom.GetInstance.Next(min, max) - max));
                    }

                    break;
                }

                case AnticipatedDirection.Down:
                {
                    if (RuleLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Positive)
                    {
                        max = Math.Abs(consequentValue - min);

                        consequentValue -= (Math.Abs(PowerLawRandom.GetInstance.Next(min, max) - max));
                    }
                    if (RuleLayerConfiguration.ConvertSign(parameters.ConsequentRelationshipSign[goal.Name]) == ConsequentRelationship.Negative)
                    {
                        max = Math.Abs(consequentValue - max);

                        consequentValue += (Math.Abs(PowerLawRandom.GetInstance.Next(min, max) - max));
                    }

                    break;
                }

                default:
                {
                    throw new Exception("Not implemented for AnticipatedDirection == 'stay'");
                }
                }

                RuleConsequent consequent = RuleConsequent.Renew(priorPeriodRule.Consequent, consequentValue);
                #endregion


                #region Generating antecedent
                List <RuleAntecedentPart> antecedentList = new List <RuleAntecedentPart>(priorPeriodRule.Antecedent.Length);

                foreach (RuleAntecedentPart antecedent in priorPeriodRule.Antecedent)
                {
                    dynamic newConst = agent[antecedent.Param];

                    RuleAntecedentPart newAntecedent = RuleAntecedentPart.Renew(antecedent, newConst);

                    antecedentList.Add(newAntecedent);
                }
                #endregion

                AgentState agentState = currentIteration[agent];

                Rule generatedRule = Rule.Renew(priorPeriodRule, antecedentList.ToArray(), consequent);


                //change base ai values for the new rule
                double consequentChangeProportion = (generatedRule.Consequent.Value - priorPeriodRule.Consequent.Value) / (double)priorPeriodRule.Consequent.Value;


                Dictionary <Goal, double> baseAI = agent.AnticipationInfluence[priorPeriodRule];

                Dictionary <Goal, double> proportionalAI = new Dictionary <Goal, double>();



                agent.AssignedGoals.ForEach(g =>
                {
                    double ai = baseAI[g];

                    ConsequentRelationship relationship = RuleLayerConfiguration.ConvertSign(priorPeriodRule.Layer.LayerConfiguration.ConsequentRelationshipSign[g.Name]);

                    double difference = Math.Abs(ai * consequentChangeProportion);


                    switch (selectedGoalState.AnticipatedDirection)
                    {
                    case AnticipatedDirection.Up:
                        {
                            if (relationship == ConsequentRelationship.Positive)
                            {
                                ai += difference;
                            }
                            else
                            {
                                ai -= difference;
                            }

                            break;
                        }

                    case AnticipatedDirection.Down:
                        {
                            if (relationship == ConsequentRelationship.Positive)
                            {
                                ai -= difference;
                            }
                            else
                            {
                                ai += difference;
                            }

                            break;
                        }
                    }

                    proportionalAI.Add(g, ai);
                });


                //add the generated rule to the prototype's mental model and assign one to the agent's mental model

                if (agent.Prototype.IsSimilarRuleExists(generatedRule) == false)
                {
                    //add to the prototype and assign to current agent
                    agent.AddRule(generatedRule, layer, proportionalAI);
                }
                else if (agent.AssignedRules.Any(rule => rule == generatedRule) == false)
                {
                    //assign to current agent only
                    agent.AssignNewRule(generatedRule, proportionalAI);
                }



                if (layer.Set.Layers.Count > 1)
                {
                    //set consequent to actor's variables for next layers
                    generatedRule.Apply(agent);
                }
            }
        }