public void Initialize() { _cognitiveArchitecture = new CognitiveArchitecture { KnowledgeAndBeliefs = { HasBelief = true, HasKnowledge = true }, MessageContent = { CanReceiveBeliefs = true, CanReceiveKnowledge = true }, InternalCharacteristics = { CanLearn = true, CanForget = true, CanInfluenceOrBeInfluence = true } }; var modelEntity = new KnowledgeModelEntity { On = true }; _knowledgeModel = new KnowledgeModel(_agentId, modelEntity, _cognitiveArchitecture, Network, RandomGenerator.RandomBinary); _knowledge = new Knowledge(Network, MainOrganization.Models, "1", 1); _knowledge1 = new Knowledge(Network, MainOrganization.Models, "1", 1); _knowledge2 = new Knowledge(Network, MainOrganization.Models, "1", 1); _knowledge3 = new Knowledge(Network, MainOrganization.Models, "1", 1); _taskBits.SetMandatory(new byte[] { 0 }); _taskBits.SetRequired(new byte[] { 0 }); _actorKnowledge0 = new ActorKnowledge(_agentId, _knowledge.EntityId, _knowledge0Bits, 0, -1); _actorKnowledge1 = new ActorKnowledge(_agentId, _knowledge1.EntityId, _knowledge1Bits, 0, -1); _actorKnowledge01 = new ActorKnowledge(_agentId, _knowledge2.EntityId, _knowledge01Bits, 0, -1); _actorKnowledgeFloat = new ActorKnowledge(_agentId, _knowledge3.EntityId, _knowledgeFloatBits, 0, -1); }
public MicroCourseModel GetMicroCourseInfo(int subjectId, int stageId) { using (var metadb = new ModMetaEntities()) { MicroCourseModel micrcomodel = new MicroCourseModel(); tb_Code_ListTable2 subject = metadb.tb_Code_ListTable2.Where(w => w.ID == subjectId && w.Deleted == 0).FirstOrDefault(); micrcomodel.subjectID = subject.ID; micrcomodel.subjectName = subject.CodeName; micrcomodel.knowledgeList = new List <KnowledgeModel>(); List <tb_Code_Knowledge> knowlist = metadb.tb_Code_Knowledge.Where(w => w.SubjectID == subjectId && w.StageID == stageId && w.Deleted == 0 && w.ParentID == 0).OrderBy(o => o.Seq).ToList(); foreach (tb_Code_Knowledge konwledge in knowlist) { KnowledgeModel knowledgemodel = new KnowledgeModel(); knowledgemodel.ID = konwledge.ID; knowledgemodel.stage = konwledge.StageID; knowledgemodel.subject = konwledge.SubjectID; knowledgemodel.CodeName = konwledge.CodeName; knowledgemodel.Children = GetKnowlegeList(metadb, knowledgemodel.ID); micrcomodel.knowledgeList.Add(knowledgemodel); } if (CacheHelper.Get("CataIds") == null) { List <tb_Code_Knowledge> listcatas = metadb.tb_Code_Knowledge.Where(w => w.Deleted == 0 && w.SubjectID == subjectId && w.StageID == stageId).OrderBy(o => o.Seq).ToList(); CacheHelper.Insert("CataIds", listcatas); } return(micrcomodel); } }
/// <summary> /// Customize the models of the agent /// After setting the Agent basics models /// </summary> public override void SetModels() { base.SetModels(); KnowledgeModel.AddKnowledge(((ExampleEnvironment)Environment).ExampleMainOrganization.Knowledge.EntityId, KnowledgeLevel.Expert, Cognitive.InternalCharacteristics); }
public KnowledgeCsView(KnowledgeController controller, KnowledgeModel model) { log.Debug(" cs observer ctor ... "); this.controller = controller; this.model = model; }
/// <summary> /// Customize the models of the agent /// After setting the Agent basics models /// </summary> public override void SetModels() { base.SetModels(); foreach (var knowledgeId in Environment.MainOrganization.ArtifactNetwork.Knowledge.GetEntityIds()) { KnowledgeModel.AddKnowledge(knowledgeId, MainOrganization.KnowledgeLevel, Cognitive.InternalCharacteristics); } }
/// <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)); }
public KnowledgeEditorViewModel(IEventAggregator eventAggregator) { _eventAggregator = eventAggregator; _saveCommand = new DelegateCommand <Window>(window => Accept(window), CanExecuteSaveCommand); _loadCommand = new DelegateCommand(LoadData); Knowledge = new KnowledgeModel(); }
/// <summary> /// Customize the models of the agent /// After setting the Agent basics models /// </summary> public override void SetModels() { base.SetModels(); foreach (var knowledgeId in Environment.MainOrganization.ArtifactNetwork.Knowledge.GetEntityIds()) { KnowledgeModel.AddKnowledge(knowledgeId, KnowledgeLevel.FullKnowledge, Cognitive.InternalCharacteristics); BeliefsModel.AddBeliefFromKnowledgeId(knowledgeId, Cognitive.KnowledgeAndBeliefs.DefaultBeliefLevel); } }
public void Initialize() { _knowledge = new Knowledge(Network, MainOrganization.Models, "1", 1); _knowledgeModel = new KnowledgeModel(Uid1, new KnowledgeModelEntity(), new CognitiveArchitecture(), Network, RandomGenerator.RandomBinary) { On = true }; _taskBits.SetMandatory(new byte[] { 0 }); _taskBits.SetRequired(new byte[] { 0 }); }
public KnowledgeTreeView(KnowledgeController controller, KnowledgeModel model, KnowledgeControl control) { log.Debug(" tree view ctor ... "); this.controller = controller; this.model = model; this.control = control; // TODO: disable all tabs initially this.control.Enabled = false; }
public async Task <bool> DeletedAsync(KnowledgeModel entity) { var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge); var result = await collection.DeleteOneAsync(d => d.ID == entity.ID); //check the document count var docs = await collection.Find(new BsonDocument()).ToListAsync(); Console.WriteLine("document count: " + docs.Count); return(result.DeletedCount == 1); }
public ActionResult Index(KnowledgeModel model) { var degreeList = _bookService.GetDegreeList(); model.DegreeItemList = degreeList.ToSelectItems(); model.DegreeItemList.Insert(0, new SelectListItem() { Text = "请选择", Value = "0" }); model.SubjectItemList.Insert(0, new SelectListItem() { Text = "请选择", Value = "0" }); return(View(model)); }
public async Task <KnowledgeModel> SaveAsync(KnowledgeModel entity) { var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge); await collection.InsertOneAsync(entity as KnowledgeModel); Console.WriteLine("document added: " + entity.ToJson()); var filter = new BsonDocument(); Console.WriteLine("count:" + collection.CountDocuments(filter).ToString()); return(entity); }
public async Task <KnowledgeModel> UpdateAsync(KnowledgeModel entity) { var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge); await collection.ReplaceOneAsync(d => d.ID == entity.ID, entity); Console.WriteLine("document updated: " + entity.ToJson()); var filter = new BsonDocument(); Console.WriteLine("count:" + collection.CountDocuments(filter).ToString()); return(entity); }
/// <summary> /// 递归目录节点 /// </summary> /// <param name="db"></param> /// <param name="parentId"></param> /// <returns></returns> private List <KnowledgeModel> GetKnowlegeList(ModMetaEntities db, int parentId) { List <KnowledgeModel> knowledgeList = new List <KnowledgeModel>(); List <tb_Code_Knowledge> tempkonwledgeList = db.tb_Code_Knowledge.Where(w => w.Deleted == 0 && w.ParentID == parentId).OrderBy(o => o.Seq).ToList(); foreach (tb_Code_Knowledge konwledge in tempkonwledgeList) { KnowledgeModel knowledgemodel = new KnowledgeModel(); knowledgemodel.ID = konwledge.ID; knowledgemodel.stage = konwledge.StageID; knowledgemodel.subject = konwledge.SubjectID; knowledgemodel.CodeName = konwledge.CodeName; knowledgemodel.Children = null; knowledgeList.Add(knowledgemodel); } return(knowledgeList); }
/// <summary> /// Finalize all the agent's cognitive models /// </summary> protected override void FinalizeModels() { base.FinalizeModels(); if (KnowledgeModel.On) { KnowledgeModel.InitializeExpertise(Schedule.Step); foreach (var knowledgeId in KnowledgeModel.Expertise.Select(x => x.Target)) { BeliefsModel.AddBeliefFromKnowledgeId(knowledgeId); } } if (BeliefsModel.On) { BeliefsModel.InitializeBeliefs(); } }
private void AddKnowledge(KnowledgeModel data) { if (Developer != null) { if (Developer.KnowledgeBase == null) { Developer.KnowledgeBase = new ObservableCollection <KnowledgeModel>(); } if (Developer.KnowledgeBase.Any(p => p.ID == data.ID) || Developer.KnowledgeBase.Any(p => p.Language == data.Language && p.Technology == data.Technology)) { return; } Developer.KnowledgeBase.Add(data); SeletedIndex = 0; } }
/// <summary> /// Initialize all the agent's cognitive models /// Should be called after SetTemplate and after having customized the cognitive parameters /// </summary> protected override void InitializeModels() { base.InitializeModels(); // Initialize agent models KnowledgeModel = new KnowledgeModel(AgentId, Environment.MainOrganization.Models.Knowledge, Cognitive, Environment.MainOrganization.ArtifactNetwork, Environment.MainOrganization.Models.Generator); BeliefsModel = new BeliefsModel(AgentId, Environment.MainOrganization.Models.Beliefs, Cognitive, Environment.MainOrganization.ArtifactNetwork, Environment.MainOrganization.Models.Generator); LearningModel = new LearningModel(AgentId, Environment.MainOrganization.Models, Environment.MainOrganization.ArtifactNetwork.Knowledge, Environment.MainOrganization.ArtifactNetwork.ActorKnowledge, Cognitive, Environment.MainOrganization.Models.Generator, Environment.RandomLevelValue); ForgettingModel = new ForgettingModel(AgentId, Environment.MainOrganization.ArtifactNetwork.ActorKnowledge, Cognitive, Environment.MainOrganization.Models, Environment.RandomLevelValue); InfluenceModel = new InfluenceModel(Environment.MainOrganization.Models.Influence, Cognitive, Environment.AgentNetwork, BeliefsModel, Environment.MainOrganization.Models.Generator); TaskModel = new ActorTaskModel(AgentId, Cognitive, Environment.MainOrganization.ArtifactNetwork); }
/// <summary> /// Returns the KnowledgeSetModel that contains this KnowledgeModel /// </summary> /// <param name="knowledgeModel"></param> /// <returns></returns> public static KnowledgeSetModel GetKnowledgeSet(this KnowledgeModel knowledgeModel) { var sets = Game.instance?.model?.knowledgeSets; if (sets is null || sets.Length == 0) { return(null); } foreach (var set in sets) { if (set.ContainsKnowledgeModel(knowledgeModel)) { return(set); } } return(null); }
public void KnowsEnoughTest() { var knowledge4 = new Knowledge(Network, MainOrganization.Models, "1", 1); var actorKnowledge = new ActorKnowledge(_agentId, knowledge4.EntityId, KnowledgeLevel.BasicKnowledge, 0, -1); // Non passing test Assert.IsFalse(KnowledgeModel.KnowsEnough(actorKnowledge, 0, Threshold, 0)); // Passing tests Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, 0, 0)); Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, Threshold, 0)); Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 1, Threshold, 0)); Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 0, Threshold, 0)); Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 1, Threshold, 0)); Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge01, 0, Threshold, 0)); Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge01, 1, Threshold, 0)); Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 0, Threshold, 0)); Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 1, Threshold, 0)); }
/// <summary> /// Returns whether or not this KnowledgeSetModel contains <paramref name="containsModel"/> /// </summary> /// <param name="set"></param> /// <param name="containsModel"></param> /// <returns></returns> public static bool ContainsKnowledgeModel(this KnowledgeSetModel set, KnowledgeModel containsModel) { if (set.tiers == null) { return(false); } List <KnowledgeLevelModel> levels = new List <KnowledgeLevelModel>(); set.tiers.ForEach(tier => levels.AddRange(tier.levels)); if (levels.Count == 0) { return(false); } List <KnowledgeModel> knowledgeModels = new List <KnowledgeModel>(); levels.ForEach(level => knowledgeModels.AddRange(level.items)); return(knowledgeModels.Any(model => model.Equals(containsModel))); }
/// <summary> /// Check Knowledge required by a task against the worker expertise /// </summary> /// <param name="knowledgeId"></param> /// <param name="taskBitIndexes">KnowledgeBits indexes of the task that must be checked against worker Knowledge</param> /// <param name="knowledgeModel"></param> /// <param name="mandatoryCheck"></param> /// <param name="requiredCheck"></param> /// <param name="mandatoryIndex"></param> /// <param name="requiredIndex"></param> /// <param name="step"></param> public void CheckKnowledge(IAgentId knowledgeId, TaskKnowledgeBits taskBitIndexes, KnowledgeModel knowledgeModel, ref bool mandatoryCheck, ref bool requiredCheck, ref byte mandatoryIndex, ref byte requiredIndex, ushort step) { if (taskBitIndexes is null) { throw new ArgumentNullException(nameof(taskBitIndexes)); } if (knowledgeModel == null) { throw new ArgumentNullException(nameof(knowledgeModel)); } // model is off if (!IsAgentOn()) { mandatoryCheck = true; requiredCheck = true; return; } // agent may don't have the knowledge at all var actorKnowledge = knowledgeModel.GetActorKnowledge(knowledgeId); if (actorKnowledge == null) { return; } mandatoryCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetMandatory(), out mandatoryIndex, ThresholdForReacting, step); requiredCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetRequired(), out requiredIndex, ThresholdForReacting, step); }
public async Task <KnowledgeModel> UpdateAsync(KnowledgeModel entity) { return(await _repository.UpdateAsync(entity)); }
/// <summary> /// Customize the models of the agent /// After setting the Agent basics models /// </summary> public override void SetModels() { base.SetModels(); KnowledgeModel.AddKnowledge(MainOrganization.Knowledge.EntityId, MainOrganization.KnowledgeLevel, Cognitive.InternalCharacteristics); }
private void RemoveKnowledge(KnowledgeModel item) { Developer.KnowledgeBase.Remove(item); }
public KnowledgeStore() { _model = new KnowledgeModel(); }
public async Task <bool> DeletedAsync(KnowledgeModel entity) { return(await _repository.DeletedAsync(entity)); }