/// <summary>
/// Try different strategy to unblocked the blocker from incomplete knowledge
/// Other strategies failed. Asking externally of the organization (to override)
/// Don't forget to call RecoverBlockerIncompleteKnowledgeByGuessing as the last chance to unblock the task
/// </summary>
/// <param name="task"></param>
/// <param name="blocker"></param>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBit"></param>
public virtual void TryRecoverBlockerIncompleteKnowledgeExternally(SymuTask task, Blocker blocker,
IAgentId knowledgeId,
byte knowledgeBit)
{
RecoverBlockerIncompleteKnowledgeByGuessing(task, blocker, knowledgeId, knowledgeBit,
BlockerResolution.Guessing);
}
public void Reply(IAgentId receiverId, MessageAction action, byte content, MessageAttachments parameter,
CommunicationMediums communicationMedium)
{
var message = new Message(AgentId, receiverId, action, content, parameter, communicationMedium);
Reply(message);
}
/// <summary>
/// Remove the first item of the Required Array, because the task has been done
/// </summary>
/// <param name="knowledgeId"></param>
public void RemoveFirstMandatory(IAgentId knowledgeId)
{
var bits = GetBits(knowledgeId);
if (bits is null)
{
return;
}
byte[] removedMandatory;
if (bits.GetMandatory().Length > 1)
{
removedMandatory = new byte[bits.GetMandatory().Length - 1];
for (byte i = 1; i < bits.GetMandatory().Length; i++)
{
removedMandatory[i - 1] = bits.GetMandatory()[i];
}
}
else
{
removedMandatory = new byte[0];
}
bits.SetMandatory(removedMandatory);
}
public ForgettingModel(IAgentId agentId, TwoModesNetwork <IEntityKnowledge> entityKnowledgeNetwork,
CognitiveArchitecture cognitive, ForgettingModelEntity entity, bool knowledgeModelOn, byte randomLevel)
{
if (entity is null)
{
throw new ArgumentNullException(nameof(entity));
}
if (cognitive is null)
{
throw new ArgumentNullException(nameof(cognitive));
}
_agentId = agentId;
_entityKnowledgeNetwork =
entityKnowledgeNetwork ?? throw new ArgumentNullException(nameof(entityKnowledgeNetwork));
InternalCharacteristics = cognitive.InternalCharacteristics;
_randomLevel = randomLevel;
entity.CopyTo(this);
if (!knowledgeModelOn || !cognitive.KnowledgeAndBeliefs.HasKnowledge || !InternalCharacteristics.CanForget)
{
// If KnowledgeModel Off or has no knowledge, there is no knowledge to forget
// Agent is not concerned by this model
On = false;
}
}
/// <summary>
/// Check a particular beliefId from Task.BeliefBits against Agent.Beliefs
/// Prevent the agent from acting on a particular belief
/// Task may be blocked if it is the case
/// </summary>
public void CheckBlockerIncompleteBelief(SymuTask task, IAgentId knowledgeId)
{
if (task is null)
{
throw new ArgumentNullException(nameof(task));
}
if (!Environment.MainOrganization.Murphies.IncompleteBelief.On ||
!Environment.MainOrganization.Models.Beliefs.On)
{
return;
}
var taskBits = task.KnowledgesBits.GetBits(knowledgeId);
float mandatoryScore = 0;
float requiredScore = 0;
byte mandatoryIndex = 0;
byte requiredIndex = 0;
var belief = BeliefsModel.GetBeliefFromKnowledgeId(knowledgeId);
var actorBelief = BeliefsModel.GetActorBelief(belief.EntityId);
Environment.MainOrganization.Murphies.IncompleteBelief.CheckBelief(belief, taskBits, actorBelief,
ref mandatoryScore, ref requiredScore,
ref mandatoryIndex, ref requiredIndex);
if (Math.Abs(mandatoryScore + requiredScore) < Tolerance)
{
// Check belief is ok
return;
}
CheckBlockerIncompleteBelief(task, knowledgeId, mandatoryScore, requiredScore, mandatoryIndex,
requiredIndex);
}
/// <summary>
/// Subscribe to the Message content
/// </summary>
public void Subscribe(IAgentId agentId, byte content)
{
if (!HasSubscribed(agentId, content))
{
_subscriptions.Add(new MessageSubscription(agentId, content));
}
}
/// <summary>
/// Initialize Knowledge model :
/// update NetworkKnowledges
/// </summary>
/// <param name="agentId"></param>
/// <param name="entity"></param>
/// <param name="cognitiveArchitecture"></param>
/// <param name="network"></param>
/// <param name="model"></param>
public KnowledgeModel(IAgentId agentId, KnowledgeModelEntity entity,
CognitiveArchitecture cognitiveArchitecture,
GraphMetaNetwork network, RandomGenerator model)
{
if (entity is null)
{
throw new ArgumentNullException(nameof(entity));
}
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
if (cognitiveArchitecture == null)
{
throw new ArgumentNullException(nameof(cognitiveArchitecture));
}
On = entity.IsAgentOn();
_agentId = agentId;
_knowledgeNetwork = network.Knowledge;
_actorKnowledgeNetwork = network.ActorKnowledge;
_knowledgeAndBeliefs = cognitiveArchitecture.KnowledgeAndBeliefs;
_messageContent = cognitiveArchitecture.MessageContent;
_model = model;
}
/// <summary>
/// Agent learn from an other agent who send KnowledgeBits.
/// Knowledge is stored in NetworkKnowledges
/// </summary>
/// <param name="knowledgeId">the knowledge Id to learn</param>
/// <param name="knowledgeBits">the knowledge Bits to learn</param>
/// <param name="maxRateLearnable">Maximum rate learnable from the message, depending on the medium used</param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
/// <param name="step"></param>
public void Learn(IAgentId knowledgeId, Bits knowledgeBits, float maxRateLearnable, float minimumKnowledge,
short timeToLive, ushort step)
{
if (!IsAgentOn())
{
return;
}
if (knowledgeId == null)
{
throw new ArgumentNullException(nameof(knowledgeId));
}
if (knowledgeId.IsNull || knowledgeBits == null || Math.Abs(TasksAndPerformance.LearningRate) < Tolerance ||
Math.Abs(maxRateLearnable) < Tolerance)
{
return;
}
if (!knowledgeId.IsNull && knowledgeBits == null)
{
throw new ArgumentNullException(nameof(knowledgeBits));
}
LearnNewKnowledge(_agentId, knowledgeId, minimumKnowledge, timeToLive, step);
var agentKnowledge = _entityKnowledgeNetwork.Edge <ActorKnowledge>(_agentId, knowledgeId);
Learn(knowledgeBits, maxRateLearnable, agentKnowledge, step);
}
/// <summary>
/// </summary>
/// <param name="agentId"></param>
/// <param name="models"></param>
/// <param name="knowledgeNetwork"></param>
/// <param name="entityKnowledgeNetwork">ActorKnowledgeNetwork, ResourceKnowledgeNetwork depending on the agent</param>
/// <param name="cognitiveArchitecture"></param>
/// <param name="model"></param>
/// <param name="randomLevel"></param>
public LearningModel(IAgentId agentId, MainOrganizationModels models, OneModeNetwork knowledgeNetwork,
TwoModesNetwork <IEntityKnowledge> entityKnowledgeNetwork,
CognitiveArchitecture cognitiveArchitecture, RandomGenerator model, byte randomLevel)
{
if (models == null)
{
throw new ArgumentNullException(nameof(models));
}
if (cognitiveArchitecture == null)
{
throw new ArgumentNullException(nameof(cognitiveArchitecture));
}
models.Learning.CopyTo(this);
_agentId = agentId;
TasksAndPerformance = cognitiveArchitecture.TasksAndPerformance;
_internalCharacteristics = cognitiveArchitecture.InternalCharacteristics;
_knowledgeNetwork = knowledgeNetwork;
_entityKnowledgeNetwork =
entityKnowledgeNetwork ?? throw new ArgumentNullException(nameof(entityKnowledgeNetwork));
_randomLevel = randomLevel;
if (!cognitiveArchitecture.InternalCharacteristics.CanLearn ||
!cognitiveArchitecture.KnowledgeAndBeliefs.HasKnowledge)
{
// Agent is not concerned by this model
On = false;
}
_model = model;
}
/// <summary>
/// Initializes a new instance of the Message class.
/// </summary>
/// <param name="senderId">The name of the agent that sends the message</param>
/// <param name="receiverId">The name of the agent that needs to receive the message</param>
/// <param name="action"></param>
/// <param name="subject">The subject of the message</param>
public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject) : this()
{
Sender = senderId;
Receiver = receiverId;
Action = action;
Subject = subject;
}
/// <summary>
/// The agent have received a message that ask for belief in return
/// stochastic Filtering agentKnowledge based on MinimumBitsOfKnowledgeToSend/MaximumBitsOfKnowledgeToSend
/// Work with non binary KnowledgeBits
/// </summary>
/// <returns>null if he don't have the belief or the right</returns>
/// <returns>a beliefBits if he has the belief or the right</returns>
/// <returns>With binary KnowledgeBits it will return a float of 0</returns>
/// <example>KnowledgeBits[0,1,0.6] and MinimumKnowledgeToSend = 0.8 => KnowledgeBits[0,1,0]</example>
public Bits FilterBeliefToSendFromKnowledgeId(IAgentId knowledgeId, byte beliefBit,
CommunicationTemplate medium)
{
var beliefId = GetBeliefIdFromKnowledgeId(knowledgeId);
return(FilterBeliefToSend(beliefId, beliefBit, medium));
}
/// <summary>
/// Constructor with standard agent template
/// and with an existing IAgentId
/// </summary>
/// <param name="agentId"></param>
/// <param name="environment"></param>
protected ReactiveAgent(IAgentId agentId, SymuEnvironment environment)
{
AgentId = agentId;
Environment = environment ?? throw new ArgumentNullException(nameof(environment));
Environment.AgentNetwork.AddAgent(this);
State = AgentState.NotStarted;
Created = Schedule.Step;
}
/// <summary>
/// Get a typed agent by its agentId
/// </summary>
/// <typeparam name="TAgent"></typeparam>
/// <param name="agentId"></param>
/// <returns>The typed agent</returns>
public TAgent Get <TAgent>(IAgentId agentId) where TAgent : T
{
if (Exists(agentId))
{
return(_list[agentId] as TAgent);
}
return(null);
}
public bool Exists(IAgentId agentId)
{
if (agentId == null)
{
throw new ArgumentNullException(nameof(agentId));
}
return(_list.ContainsKey(agentId));
}
/// <summary>
/// Check Knowledge required against the worker expertise
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBit">KnowledgeBit index of the task that must be checked against worker Knowledge</param>
/// <param name="knowledgeModel"></param>
/// <param name="step"></param>
/// <returns>False if the agent is On and if the knowledgeBit is not known enough</returns>
/// <returns>True if the agent is not On or the knowledgeBit is known enough</returns>
public bool CheckKnowledge(IAgentId knowledgeId, byte knowledgeBit, KnowledgeModel knowledgeModel, ushort step)
{
if (knowledgeModel == null)
{
throw new ArgumentNullException(nameof(knowledgeModel));
}
return(!IsAgentOn() || knowledgeModel.KnowsEnough(knowledgeId, knowledgeBit, ThresholdForReacting, step));
}
/// <summary>
/// Add an agentId's beliefs
/// using the beliefLevel
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefLevel"></param>
public void AddBelief(IAgentId beliefId, BeliefLevel beliefLevel)
{
if (!On)
{
return;
}
ActorBelief.CreateInstance(_actorBeliefNetwork, _agentId, beliefId, beliefLevel);
}
/// <summary>
/// Constructor based on the knowledge Id and the knowledge Level.
/// KnowledgeBits is not yet initialized.
/// NetworkKnowledges.InitializeAgentKnowledge must be called to initialized KnowledgeBits
/// </summary>
/// <param name="actorId"></param>
/// <param name="knowledgeId"></param>
/// <param name="level"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
public ActorKnowledge(IAgentId actorId, IAgentId knowledgeId, KnowledgeLevel level, float minimumKnowledge,
short timeToLive) : base(actorId, knowledgeId)
{
KnowledgeLevel = level;
MinimumKnowledge = minimumKnowledge;
TimeToLive = timeToLive;
KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive);
Length = KnowledgeBits.Length;
}
/// <summary>
/// Constructor based on the knowledge Id and the knowledge Level.
/// KnowledgeBits is not yet initialized.
/// NetworkKnowledges.InitializeAgentKnowledge must be called to initialized KnowledgeBits
/// </summary>
/// <param name="network"></param>
/// <param name="actorId"></param>
/// <param name="knowledgeId"></param>
/// <param name="level"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
public ActorKnowledge(TwoModesNetwork <IEntityKnowledge> network, IAgentId actorId, IAgentId knowledgeId, KnowledgeLevel level, float minimumKnowledge,
short timeToLive) : base(network, actorId, knowledgeId)
{
KnowledgeLevel = level;
MinimumKnowledge = minimumKnowledge;
TimeToLive = timeToLive;
KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive);
Length = KnowledgeBits.Length;
}
/// <summary>
/// Add an agentId's Knowledge to the network
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBits"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
public void AddKnowledge(IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge, short timeToLive)
{
if (!On || !_knowledgeAndBeliefs.HasKnowledge)
{
return;
}
ActorKnowledge.CreateInstance(_actorKnowledgeNetwork, _agentId, knowledgeId, knowledgeBits, minimumKnowledge, timeToLive);
}
/// <summary>
/// Store the knowledge bit of the KnowledgeId in the Database
/// The Knowledge must have been InitializeKnowledge first
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBit"></param>
/// <param name="knowledgeValue"></param>
/// <param name="step"></param>
public void StoreKnowledge(IAgentId knowledgeId, byte knowledgeBit, float knowledgeValue, ushort step)
{
if (!ExistsKnowledge(knowledgeId))
{
throw new ArgumentNullException("knowledgeId must have been initialized first");
}
_learningModel.AgentKnowledgeLearn(GetKnowledge(knowledgeId), knowledgeBit, knowledgeValue, step);
}
/// <summary>
/// Constructor used by Agent.Cognitive for ForgettingKnowledge
/// </summary>
/// <param name="network"></param>
/// <param name="actorId"></param>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBits"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
/// <param name="step"></param>
public ActorKnowledge(TwoModesNetwork <IEntityKnowledge> network, IAgentId actorId, IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge,
short timeToLive, ushort step = 0) : base(network, actorId, knowledgeId)
{
MinimumKnowledge = minimumKnowledge;
TimeToLive = timeToLive;
KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive);
KnowledgeBits.SetBits(knowledgeBits, step);
Length = KnowledgeBits.Length;
}
/// <summary>
/// Constructor used by Agent.Cognitive for ForgettingKnowledge
/// </summary>
/// <param name="actorId"></param>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBits"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
/// <param name="step"></param>
public ActorKnowledge(IAgentId actorId, IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge,
short timeToLive,
ushort step = 0) : base(actorId, knowledgeId)
{
MinimumKnowledge = minimumKnowledge;
TimeToLive = timeToLive;
KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive);
KnowledgeBits.SetBits(knowledgeBits, step);
Length = KnowledgeBits.Length;
}
/// <summary>
/// Agent don't have still this belief, it's time to learn a new one
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefLevel"></param>
public void LearnNewBelief(IAgentId beliefId, BeliefLevel beliefLevel)
{
if (_actorBeliefNetwork.Exists(_agentId, beliefId))
{
return;
}
ActorBelief.CreateInstance(_actorBeliefNetwork, _agentId, beliefId, beliefLevel);
InitializeBeliefs(true);
}
public void SetKnowledge(IAgentId knowledgeId, byte index, float value, ushort step)
{
var actorKnowledge = GetActorKnowledge(knowledgeId);
if (actorKnowledge == null)
{
throw new NullReferenceException(nameof(actorKnowledge));
}
actorKnowledge.SetKnowledgeBit(index, value, step);
}
public void SetKnowledge(IAgentId knowledgeId, float[] knowledgeBits, ushort step)
{
var actorKnowledge = GetActorKnowledge(knowledgeId);
if (actorKnowledge == null)
{
throw new NullReferenceException(nameof(actorKnowledge));
}
actorKnowledge.SetKnowledgeBits(knowledgeBits, step);
}
public bool ExistsAndStarted(IAgentId agentId)
{
if (!ExistsAgent(agentId))
{
return(false);
}
var agent = GetAgent(agentId);
return(agent != null && agent.State == AgentState.Started);
}
/// <summary>
/// Check that agent has the BeliefId[knowledgeBit] == 1
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefBit"></param>
/// <param name="beliefThreshHoldForAnswer"></param>
/// <returns>true if the agent has the knowledge</returns>
public bool BelievesEnough(IAgentId beliefId, byte beliefBit, float beliefThreshHoldForAnswer)
{
if (!_actorBeliefNetwork.Exists(_agentId, beliefId))
{
return(false);
}
var belief = _actorBeliefNetwork.Edge <ActorBelief>(_agentId, beliefId);
return(belief.BelievesEnough(beliefBit, beliefThreshHoldForAnswer));
}
public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject,
MessageAttachments attachments, CommunicationMediums medium)
: this(senderId, receiverId, action, subject, medium)
{
if (attachments == null)
{
return;
}
Attachments = attachments;
}
public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject,
MessageAttachments attachments)
: this(senderId, receiverId, action, subject)
{
if (attachments == null)
{
return;
}
Attachments = attachments;
}
/// <summary>
/// Add an agentId's Knowledge to the network
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="level"></param>
/// <param name="internalCharacteristics"></param>
public void AddKnowledge(IAgentId knowledgeId, KnowledgeLevel level,
InternalCharacteristics internalCharacteristics)
{
if (internalCharacteristics == null)
{
throw new ArgumentNullException(nameof(internalCharacteristics));
}
AddKnowledge(knowledgeId, level, internalCharacteristics.MinimumRemainingKnowledge,
internalCharacteristics.TimeToLive);
}
